sxn 0.2.0

data/.gem_rbs_collection/concurrent-ruby/1.1/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: concurrent-ruby
+version: '1.1'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 6a12ebdb5a08a2eecc32622efce9c644684c1c52
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/concurrent-ruby/1.1/array.rbs

@@ -0,0 +1,4 @@
+module Concurrent
+  class Array[T] < ::Array[T]
+  end
+end

data/.gem_rbs_collection/concurrent-ruby/1.1/executor.rbs

@@ -0,0 +1,26 @@
+module Concurrent
+  module ExecutorService
+    interface _Task
+      def call: () -> void
+    end
+
+    def post: [A] (*A args) { (*A args) -> void } -> bool
+
+    def <<: (_Task task) -> bool
+
+    def can_overflow?: () -> bool
+
+    def serialized?: () -> bool
+  end
+
+  type executor = ExecutorService | :io | :fast | :immediate
+
+  def self.executor: (executor executor_identifier) -> ExecutorService
+
+  def self.global_io_executor: () -> ExecutorService
+  def self.global_fast_executor: () -> ExecutorService
+  def self.global_immediate_executor: () -> ExecutorService
+
+  def self.new_io_executor: (?Hash[Symbol, untyped] opts) -> ExecutorService
+  def self.new_fast_executor: (?Hash[Symbol, untyped] opts) -> ExecutorService
+end

data/.gem_rbs_collection/concurrent-ruby/1.1/hash.rbs

@@ -0,0 +1,4 @@
+module Concurrent
+  class Hash[K, V] < ::Hash[K, V]
+  end
+end

data/.gem_rbs_collection/concurrent-ruby/1.1/map.rbs

@@ -0,0 +1,65 @@
+module Concurrent
+  class Map[unchecked out K, unchecked out V]
+    def initialize: (?Hash[Symbol, untyped] options) ?{ (self, untyped) -> V } -> void
+
+    def []: (untyped key) -> V?
+    def []=: (K key, V value) -> V
+
+    alias get []
+    alias put []=
+
+    def compute: (K key) { (V? old_value) -> V } -> V
+               | (K key) { (V? old_value) -> nil } -> nil
+
+    def compute_if_absent: (K key) { () -> V } -> V
+
+    def compute_if_present: (K key) { (V old_value) -> V? } -> V?
+
+    def fetch: (untyped key) -> V
+             | [D] (untyped key, D default_value) -> (V | D)
+             | [T, D] (T key) { (T key) -> D } -> (V | D)
+
+    def fetch_or_store: (untyped key) -> V
+                      | (K key, V default_value) -> V
+                      | (K key) { (K key) -> V } -> V
+
+    def put_if_absent: (K key, V value) -> V?
+
+    def value?: (untyped value) -> bool
+
+    def keys: () -> Array[K]
+
+    def values: () -> Array[V]
+
+    def each_key: () { (K key) -> void } -> self
+
+    def each_value: () { (V value) -> void } -> self
+
+    def each_pair: () { (K key, V value) -> void } -> self
+
+    alias each each_pair
+
+    def key: (untyped value) -> K?
+
+    def empty?: () -> bool
+
+    def size: () -> Integer
+
+    def marshal_dump: () -> Hash[K, V]
+    def marshal_load: (Hash[K, V] hash) -> self
+
+    # undef :freeze
+
+    def inspect: () -> String
+
+    private
+
+    def raise_fetch_no_key: () -> bot
+
+    def initialize_copy: (instance other) -> void
+
+    def populate_from: (Hash[K, V] hash) -> self
+
+    def validate_options_hash!: (Hash[Symbol, untyped] options) -> void
+  end
+end

data/.gem_rbs_collection/concurrent-ruby/1.1/promises.rbs

@@ -0,0 +1,249 @@
+module Concurrent
+  module Promises
+    module FactoryMethods
+      def any_event: (*(Event | Future[top, top]) futures_and_or_events) -> Event
+      def any_event_on: (executor default_executor, *(Event | Future[top, top]) futures_and_or_events) -> Event
+
+      def any_fulfilled_future: (*Event events) -> Future[nil, bot]
+        | [T, E] (*Future[T, E] futures) -> Future[T, E]
+        | [T, E] (*(Event | Future[T, E]) futures_and_or_events) -> Future[T | nil, E]
+      def any_fulfilled_future_on: (executor default_executor, *Event events) -> Future[nil, bot]
+        | [T, E] (executor default_executor, *Future[T, E] futures) -> Future[T, E]
+        | [T, E] (executor default_executor, *(Event | Future[T, E]) futures_and_or_events) -> Future[T | nil, E]
+
+      def any_resolved_future: (*Event events) -> Future[nil, bot]
+        | [T, E] (*Future[T, E] futures) -> Future[T, E]
+        | [T, E] (*(Event | Future[T, E]) futures_and_or_events) -> Future[T | nil, E]
+      alias any any_resolved_future
+      def any_resolved_future_on: (executor default_executor, *Event events) -> Future[nil, bot]
+        | [T, E] (executor default_executor, *Future[T, E] futures) -> Future[T, E]
+        | [T, E] (executor default_executor, *(Event | Future[T, E]) futures_and_or_events) -> Future[T | nil, E]
+
+      def default_executor: () -> executor
+
+      def delay: () -> Event
+        | [A, T] (*A args) { (*A args) -> T } -> Future[T, Exception]
+      def delay_on: (executor default_executor) -> Event
+        | [A, T] (executor default_executor, *A args) { (*A args) -> T } -> Future[T, Exception]
+
+      def fulfilled_future: [T] (T value, ?executor default_executor) -> Future[T, bot]
+
+      def future: [A, T] (*A args) { (*A args) -> T } -> Future[T, Exception]
+      def future_on: [A, T] (executor default_executor, *A args) { (*A args) -> T } -> Future[T, Exception]
+
+      def make_future: (nil, ?executor default_executor) -> Event
+        | [X < AbstractEventFuture] (X event_or_future, ?executor default_executor) -> X
+        | [E < Exception] (E reason, ?executor default_executor) -> Future[bot, E]
+        | [T] (T value, ?executor default_executor) -> Future[T, bot]
+
+      def rejected_future: [E] (E reason, ?executor default_executor) -> Future[bot, E]
+
+      def resolvable_event: () -> ResolvableEvent
+      def resolvable_event_on: (executor default_executor) -> ResolvableEvent
+
+      def resolvable_future: () -> ResolvableFuture[untyped, untyped]
+      def resolvable_future_on: (executor default_executor) -> ResolvableFuture[untyped, untyped]
+
+      def resolved_event: (?executor default_executor) -> Event
+
+      def resolved_future: [T] (true fulfilled, T value, top reason, ?executor default_executor) -> Future[T, bot]
+        | [E] (false fulfilled, top value, E reason, ?executor default_executor) -> Future[bot, E]
+        | [T, E] (boolish fulfilled, T? value, E? reason, ?executor default_executor) -> Future[T, E]
+
+      def schedule: (Numeric | Time intended_time) -> Event
+        | [A, T] (Numeric | Time intended_time, *A args) { (*A args) -> T } -> Future[T, Exception]
+      def schedule_on: (executor default_executor, Numeric | Time intended_time) -> Event
+        | [A, T] (executor default_executor, Numeric | Time intended_time, *A args) { (*A args) -> T } -> Future[T, Exception]
+
+      def zip_events: (*(Event | Future[top, top]) futures_and_or_events) -> Event
+      def zip_events_on: (executor default_executor, *(Event | Future[top, top]) futures_and_or_events) -> Event
+
+      def zip_futures: (*Event events) -> Future[::Array[nil], bot]
+        | [T, E] (*Future[T, E] futures) -> Future[::Array[T], ::Array[E]]
+        | [T, E] (*(Event | Future[T, E]) futures_and_or_events) -> Future[::Array[T | nil], ::Array[E | nil]]
+      alias zip zip_futures
+      def zip_futures_on: (executor default_executor, *Event events) -> Future[Array[nil], bot]
+        | [T, E] (executor default_executor, *Future[T, E] futures) -> Future[Array[T], Array[E]]
+        | [T, E] (executor default_executor, *(Event | Future[T, E]) futures_and_or_events) -> Future[Array[T | nil], Array[E]]
+    end
+
+    extend FactoryMethods
+
+    class AbstractEventFuture
+      def chain: [A, U] (*A args) { (*untyped) -> U } -> Future[U, Exception]
+      def chain_on: [A, U] (executor executor, *A args) { (*untyped) -> U } -> Future[U, Exception]
+
+      def chain_resolvable: (Resolvable resolvable) -> self
+      alias tangle chain_resolvable
+
+      def default_executor: () -> executor
+
+      def internal_state: () -> Object
+
+      def on_resolution: [A] (*A args) { (*untyped) -> void } -> self
+      def on_resolution!: [A] (*A args) { (*untyped) -> void } -> self
+      def on_resolution_using: [A] (executor executor, *A args) { (*untyped) -> void } -> self
+
+      def resolved?: () -> bool
+
+      def pending?: () -> bool
+
+      def state: () -> Symbol
+
+      def touch: () -> self
+
+      def wait: (?nil) -> self
+        | (Numeric timeout) -> bool
+    end
+
+    class Event < AbstractEventFuture
+      def any: (Event | Future[top, top] event_or_future) -> Event
+      alias | any
+
+      def delay: () -> Event
+
+      def schedule: (Numeric | Time intended_time) -> Event
+
+      def to_event: () -> self
+
+      def to_future: () -> Future[nil, bot]
+
+      def with_default_executor: (executor executor) -> Event
+
+      def zip: (Event event) -> Event
+        | [T, E] (Future[T, E] future) -> Future[T, E]
+      alias & zip
+
+
+      ## Following methods are actually defined in the base class and have specific types for Event
+
+      def chain: [A, U] (*A args) { (*A args) -> U } -> Future[U, Exception]
+      def chain_on: [A, U] (executor executor, *A args) { (*A args) -> U } -> Future[U, Exception]
+
+      def on_resolution: [A] (*A args) { (*A args) -> void } -> self
+      def on_resolution!: [A] (*A args) { (*A args) -> void } -> self
+      def on_resolution_using: [A] (executor executor, *A args) { (*A args) -> void } -> self
+
+      def state: () -> (:pending | :resolved)
+    end
+
+    class Future[out T, out E] < AbstractEventFuture
+      def any: (Event event) -> Future[T | nil, E]
+        | [T2, E2] (Future[T2, E2] future) -> Future[T | T2, E | E2]
+      alias | any
+
+      def delay: () -> Future[T, E]
+
+      def exception: () -> Exception  # TODO: Return type can be narrowed to E when E <: Exception
+
+      def flat_event: () -> Event
+
+      def flat_future: (?Integer level) -> untyped  # TODO: Valid only if T <: Future[top, top]
+      alias flat flat_future
+
+      def fulfilled?: () -> bool
+
+      def on_fulfillment: [A] (*A args) { (T value, *A args) -> void } -> self
+      def on_fulfillment!: [A] (*A args) { (T value, *A args) -> void } -> self
+      def on_fulfillment_using: [A] (executor executor, *A args) { (T value, A args) -> void } -> self
+
+      def on_rejection: [A] (*A args) { (E reason, *A args) -> void } -> self
+      def on_rejection!: [A] (*A args) { (E reason, *A args) -> void } -> self
+      def on_rejection_using: [A] (executor executor, *A args) { (E reason, A args) -> void } -> self
+
+      def reason: (?Numeric timeout) -> (E | nil)
+        | [R] (Numeric timeout, R timeout_value) -> (E | R | nil)
+
+      def rejected?: () -> bool
+
+      def rescue: [A, U] (*A args) { (E reason, *A args) -> U } -> Future[U, Exception]
+      def rescue_on: [A, U] (executor executor, *A args) { (E reason, *A args) -> U } -> Future[U, Exception]
+
+      def result: (?nil) -> ([true, T, nil] | [false, nil, E])
+        | (Numeric timeout) -> ([true, T, nil] | [false, nil, E] | nil)
+
+      def run: (?^(untyped) -> Future[untyped, untyped]? run_test) -> Future[untyped, untyped]  # TODO: Any specific type?
+
+      def schedule: (Numeric | Time intended_time) -> Future[T, E]
+
+      def then: [A, U] (*A args) { (T value, *A args) -> U } -> Future[U, E | Exception]
+      def then_on: [A, U] (executor executor, *A args) { (T value, *A args) -> U } -> Future[U, E | Exception]
+
+      def to_event: () -> Event
+
+      def to_future: () -> self
+
+      def value: (?Numeric timeout) -> (T | nil)
+        | [R] (Numeric timeout, R timeout_value) -> (T | R | nil)
+      def value!: (?nil) -> T
+        | (Numeric timeout) -> (T | nil)
+        | [R] (Numeric timeout, R timeout_value) -> (T | R | nil)
+
+      def wait!: (?nil) -> self
+        | (Numeric timeout) -> bool
+
+      def with_default_executor: (executor executor) -> Future[T, E]
+
+      def zip: (Event event) -> Future[T, E]
+        | [T2, E2] (Future[T2, E2] future) -> Future[[T, T2], [E, E2]]
+      alias & zip
+
+
+      ## Following methods are actually defined in the base class and have specific types for Future
+
+      def chain: [A, U] (*A args) { (bool fulfilled, T? value, E? reason, *A args) -> U } -> Future[U, Exception]
+      def chain_on: [A, U] (executor executor, *A args) { (bool fulfilled, T? value, E? reason, *A args) -> U } -> Future[U, Exception]
+
+      def on_resolution: [A] (*A args) { (bool fulfilled, T? value, E? reason, *A args) -> void } -> self
+      def on_resolution!: [A] (*A args) { (bool fulfilled, T? value, E? reason, *A args) -> void } -> self
+      def on_resolution_using: [A] (executor executor, *A args) { (bool fulfilled, T? value, E? reason, *A args) -> void } -> self
+
+      def state: () -> (:pending | :fulfilled | :rejected)
+    end
+
+    module Resolvable
+    end
+
+    class ResolvableEvent < Event
+      include Resolvable
+
+      def resolve: (?true raise_on_reassign, ?boolish reserved) -> self
+        | (boolish raise_on_reassign, ?boolish reserved) -> (self | false)
+
+      def wait: (Numeric timeout, boolish resolve_on_timeout) -> bool
+        | ...
+
+      def with_hidden_resolvable: () -> Event
+    end
+
+    class ResolvableFuture[T, E] < Future[T, E]  # Note: ResolvableFuture is invariant on T and E
+      include Resolvable
+
+      def evalute_to: [A] (*A args) { (*A args) -> T } -> self  # TODO: Unsound unless E :> Exception
+      def evalute_to!: [A] (*A args) { (*A args) -> T } -> self  # TODO: ditto
+
+      def fulfill:  (T value, ?true raise_on_reassign, ?boolish reserved) -> self
+        | (T value, boolish raise_on_reassign, ?boolish reserved) -> (self | false)
+
+      def reason: [R] (Numeric timeout, R timeout_value, [boolish, T?, E?] resolve_on_timeout) -> (E | R | nil)
+        | ...
+
+      def reject: (E reason, ?true raise_on_reassign, ?boolish reserved) -> self
+        | (E reason, boolish raise_on_reassign, ?boolish reserved) -> (self | false)
+
+      def resolve: (?boolish fulfilled, ?T? value, ?E? reason, ?true raise_on_reassign, ?boolish reserved) -> self
+        | (boolish fulfilled, T? value, E? reason, boolish raise_on_reassign, ?boolish reserved) -> (self | false)
+
+      def result: (Numeric timeout, [boolish, T?, E?] resolve_on_timeout) -> ([true, T, nil] | [false, nil, E] | nil)
+        | ...
+
+      def value: [R] (Numeric timeout, R timeout_value, [boolish, T?, E?] resolve_on_timeout) -> (T | R | nil)
+        | ...
+
+      def value!: [R] (Numeric timeout, R timeout_value, [boolish, T?, E?] resolve_on_timeout) -> (T | R | nil)
+        | ...
+
+      def with_hidden_resolvable: () -> Future[T, E]
+    end
+  end
+end

data/.gem_rbs_collection/concurrent-ruby/1.1/utility/processor_counter.rbs

@@ -0,0 +1,5 @@
+module Concurrent
+  def self.physical_processor_count: () -> Integer
+
+  def self.processor_count: () -> Integer
+end

data/.gem_rbs_collection/diff-lcs/1.5/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: diff-lcs
+version: '1.5'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 6a12ebdb5a08a2eecc32622efce9c644684c1c52
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/diff-lcs/1.5/diff-lcs.rbs

@@ -0,0 +1,11 @@
+module Diff
+end
+
+module Diff::LCS
+  def self.LCS: (Array[String], Array[String]) -> Array[String]
+              | (String, String) -> Array[String]
+  def self.diff: (Array[String], Array[String]) -> Array[String]
+              | (String, String) -> Array[String]
+
+  def self.patch!: (Array[String], Array[String]) -> String
+end

data/.gem_rbs_collection/listen/3.9/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: listen
+version: '3.9'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 6a12ebdb5a08a2eecc32622efce9c644684c1c52
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/listen/3.9/listen.rbs

@@ -0,0 +1,25 @@
+module Listen
+  # Listens to file system modifications on a either single directory or
+  # multiple directories.
+  #
+  # @param (see Listen::Listener#new)
+  #
+  # @yield [modified, added, removed] the changed files
+  # @yieldparam [Array<String>] modified the list of modified files
+  # @yieldparam [Array<String>] added the list of added files
+  # @yieldparam [Array<String>] removed the list of removed files
+  #
+  # @return [Listen::Listener] the listener
+  #
+  def self.to: (*String dirs,
+                ?debug: bool,
+                ?wait_for_delay: Integer?,
+                ?relative: bool,
+                ?force_polling: bool,
+                ?ignore: Regexp | Array[Regexp],
+                ?ignore!: Regexp,
+                ?only: Regexp?,
+                ?polling_fallback_message: String?) {
+                  (Array[String] modified, Array[String] added, Array[String] removed) -> void
+                } -> Listener
+end

data/.gem_rbs_collection/listen/3.9/listener.rbs

@@ -0,0 +1,24 @@
+module Listen
+  class Listener
+    # Starts processing events and starts adapters
+    # or resumes invoking callbacks if paused
+    def start: () -> void
+
+    # Stops both listening for events and processing them
+    def stop: () -> void
+
+    # Stops invoking callbacks (messages pile up)
+    def pause: () -> void
+
+    # processing means callbacks are called
+    def processing?: () -> bool
+
+    def paused?: () -> bool
+
+    def ignore: (Regexp regexps) -> void
+
+    def ignore!: (Regexp regexps) -> void
+
+    def only: (Regexp regexps) -> void
+  end
+end

data/.gem_rbs_collection/mini_mime/0.1/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: mini_mime
+version: '0.1'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 6a12ebdb5a08a2eecc32622efce9c644684c1c52
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/mini_mime/0.1/mini_mime.rbs

@@ -0,0 +1,14 @@
+module MiniMime
+  def self.lookup_by_filename: (String filename) -> Info?
+  def self.lookup_by_extension: (String extension) -> Info?
+  def self.lookup_by_content_type: (String mime) -> Info?
+
+  class Info
+    attr_accessor extension: String
+    attr_accessor content_type: String
+    attr_accessor encoding: String
+
+    def []: (Integer idx) -> String
+    def binary?: () -> bool
+  end
+end

data/.gem_rbs_collection/parallel/1.20/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: parallel
+version: '1.20'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 6a12ebdb5a08a2eecc32622efce9c644684c1c52
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/parallel/1.20/parallel.rbs

@@ -0,0 +1,86 @@
+module Parallel
+  class Break < StandardError
+    attr_reader value: untyped
+
+    def initialize: (?untyped value) -> void
+  end
+
+  class Kill < Break
+  end
+
+  type stop = Object
+  Stop: stop
+
+  VERSION: String
+
+  Version: String
+
+  type callable_source[T] = ^() -> (T | stop)
+
+  def self.all?: [T] (Enumerable[T] | callable_source[T] source,
+                      ?in_processes: Integer,
+                      ?in_threads: Integer,
+                      ?progress: _ToStr,
+                      ?start: ^(T item, Integer index) -> void,
+                      ?finish: ^(T item, Integer index, boolish result) -> void) { (T) -> boolish } -> bool
+
+  def self.any?: [T] (Enumerable[T] | callable_source[T] source,
+                      ?in_processes: Integer,
+                      ?in_threads: Integer,
+                      ?progress: _ToStr,
+                      ?start: ^(T item, Integer index) -> void,
+                      ?finish: ^(T item, Integer index, boolish result) -> void) { (T) -> boolish } -> bool
+
+  def self.each: [T, U] (Enumerable[T] source,
+                         ?in_processes: Integer,
+                         ?in_threads: Integer,
+                         ?progress: _ToStr,
+                         ?start: ^(T item, Integer index) -> void,
+                         ?finish: ^(T item, Integer index, U result) -> void) { (T) -> U } -> Enumerable[U]
+               | [T, U] (callable_source[T] source,
+                         ?in_processes: Integer,
+                         ?in_threads: Integer,
+                         ?progress: _ToStr,
+                         ?start: ^(T item, Integer index) -> void,
+                         ?finish: ^(T item, Integer index, U result) -> void) { (T) -> U } -> callable_source[T]
+
+  def self.each_with_index: [T, U] (Enumerable[T] source,
+                                    ?in_processes: Integer,
+                                    ?in_threads: Integer,
+                                    ?progress: _ToStr,
+                                    ?start: ^(T item, Integer index) -> void,
+                                    ?finish: ^(T item, Integer index, U result) -> void) { (T, Integer) -> U } -> Enumerable[T]
+                          | [T, U] (callable_source[T] array,
+                                    ?in_processes: Integer,
+                                    ?in_threads: Integer,
+                                    ?progress: _ToStr,
+                                    ?start: ^(T item, Integer index) -> void,
+                                    ?finish: ^(T item, Integer index, U result) -> void) { (T, Integer) -> U } -> callable_source[U]
+
+  def self.flat_map: [T, U] (Enumerable[T] | callable_source[T] src,
+                             ?in_processes: Integer,
+                             ?in_threads: Integer,
+                             ?progress: _ToStr,
+                             ?start: ^(T item, Integer index) -> void,
+                             ?finish: ^(T item, Integer index, U result) -> void) { (T) -> U } -> Array[U]
+
+  def self.map: [T, U] (Enumerable[T] | callable_source[T] | Thread::Queue source,
+                        ?in_processes: Integer,
+                        ?in_threads: Integer,
+                        ?progress: _ToStr,
+                        ?start: ^(T item, Integer index) -> void,
+                        ?finish: ^(T item, Integer index, U result) -> void) { (T) -> U } -> Array[U]
+
+  def self.map_with_index: [T, U] (Enumerable[T] | callable_source[T] source,
+                                   ?in_processes: Integer,
+                                   ?in_threads: Integer,
+                                   ?progress: _ToStr,
+                                   ?start: ^(T item, Integer index) -> untyped,
+                                   ?finish: ^(T item, Integer index, U result) -> untyped) { (T, Integer) -> U } -> Array[U]
+
+  def self.physical_processor_count: () -> Integer
+
+  def self.processor_count: () -> Integer
+
+  def self.worker_number: () -> Integer
+end

data/.gem_rbs_collection/rake/13.0/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: rake
+version: '13.0'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 6a12ebdb5a08a2eecc32622efce9c644684c1c52
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/rake/13.0/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: fileutils

data/.gem_rbs_collection/rake/13.0/rake.rbs

@@ -0,0 +1,39 @@
+module Rake
+  class TaskLib
+    include Rake::DSL
+  end
+
+  class Task
+  end
+
+  class TaskArguments
+    include Enumerable[untyped]
+
+    def []: (untyped index) -> untyped
+    def each: () ?{ (untyped, untyped) -> void } -> void
+  end
+
+  module DSL
+    private
+
+    include FileUtils
+
+    def desc: (String description) -> void
+    def directory: (*untyped args) ?{ () -> void } -> void
+    def file: (*untyped args) ?{ () -> void } -> void
+    def file_create: (*untyped args) ?{ () -> void } -> void
+    def import: (*String fns) -> void
+    def multitask: (*untyped args) ?{ () -> void } -> void
+    def namespace: (?untyped name) ?{ () -> void } -> void
+    def rule: (*untyped args) ?{ () -> void } -> void
+    def task: (*untyped args) ?{ (Rake::Task, Rake::TaskArguments) -> void } -> void
+  end
+end
+
+module FileUtils
+  def sh: (*String cmd, **untyped options) ?{ (bool, Process::Status) -> void } -> void
+    | (Hash[String, String] env, *String cmd, **untyped options) ?{ (bool, Process::Status) -> void } -> void
+  def ruby: (*String args, **untyped options) ?{ (bool, Process::Status) -> void } -> void
+  def safe_ln: (*untyped args, **untyped options) -> void
+  def split_all: (String path) -> Array[String]
+end

data/.gem_rbs_collection/rubocop-ast/1.46/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: rubocop-ast
+version: '1.46'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 6a12ebdb5a08a2eecc32622efce9c644684c1c52
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems