searchcraft 0.4.0 → 0.4.1

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/i18n/1.10/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: i18n
+version: '1.10'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 3e93a59bd5da185b68187991630ac9a54a2468a7
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/i18n/1.10/backend.rbs

@@ -0,0 +1,269 @@
+module I18n
+  def self.cache_store: -> untyped
+  def self.cache_store=: (untyped store) -> untyped
+  def self.cache_namespace: -> untyped
+  def self.cache_namespace=: (untyped namespace) -> untyped
+  def self.cache_key_digest: -> untyped
+  def self.cache_key_digest=: (untyped key_digest) -> untyped
+  def self.perform_caching?: -> bool
+
+  def self.fallbacks: -> untyped
+  def self.fallbacks=: (untyped fallbacks) -> untyped
+
+  class JSON
+    def self.encode: (untyped value) -> untyped
+    def self.decode: (untyped value) -> untyped
+  end
+
+  module Backend
+    module Base
+      include I18n::Backend::Transliterator
+
+      def load_translations: (*untyped filenames) { (untyped, untyped) -> untyped } -> untyped
+      def store_translations: (untyped locale, untyped data, ?untyped options) -> untyped
+      def translate: (untyped locale, untyped key, ?untyped options) -> (nil | untyped)
+      def exists?: (untyped locale, untyped key, ?untyped options) -> untyped
+      def localize: (untyped locale, untyped object, ?::Symbol format, ?untyped options) -> untyped
+      def available_locales: -> untyped
+      def reload!: -> untyped
+      def eager_load!: -> true
+      def eager_loaded?: -> bool
+      def lookup: (untyped locale, untyped key, ?untyped scope, ?untyped options) -> untyped
+      def subtrees?: -> true
+      def default: (untyped locale, untyped object, untyped subject, ?untyped options) -> untyped
+      def resolve: (untyped locale, untyped object, untyped subject, ?untyped options) -> untyped
+      def pluralize: (untyped locale, untyped entry, untyped count) -> untyped
+      def interpolate: (untyped locale, untyped subject, ?untyped values) -> untyped
+      def deep_interpolate: (untyped locale, untyped data, ?untyped values) -> untyped
+      def load_file: (String filename) -> Hash[untyped, untyped]
+      def load_rb: (String filename) -> [untyped, false]
+      def load_yml: (String filename) -> [untyped, bool]
+      def load_json: (String filename) -> [untyped, bool]
+      def translate_localization_format: (untyped locale, untyped object, untyped format, untyped options) -> untyped
+      def pluralization_key: (untyped entry, untyped count) -> Symbol
+    end
+
+    module Cache
+      def translate: (untyped locale, untyped key, ?untyped options) -> untyped
+      def fetch: (String cache_key) { -> untyped } -> untyped
+      def _fetch: (String cache_key) { -> untyped } -> untyped
+      def cache_key: (untyped locale, untyped key, untyped options) -> String
+
+      private
+      def digest_item: (untyped key) -> untyped
+    end
+
+    module CacheFile
+      attr_accessor path_roots: Array[untyped]
+      def load_file: (String filename) -> untyped
+      def normalized_path: (String file) -> String
+    end
+
+    module Cascade
+      def lookup: (untyped locale, untyped key, ?Array[untyped] scope, ?untyped options) -> untyped
+    end
+
+    class Chain
+      include Implementation
+
+      module Implementation
+        attr_accessor backends: untyped
+        def initialize: (*untyped backends) -> void
+        def initialized?: -> bool
+        def reload!: -> untyped
+        def eager_load!: -> untyped
+        def store_translations: (untyped locale, untyped data, ?untyped options) -> untyped
+        def available_locales: -> untyped
+        def translate: (untyped locale, untyped key, ?untyped default_options) -> untyped
+        def exists?: (untyped locale, untyped key, ?untyped options) -> untyped
+        def localize: (untyped locale, untyped object, ?untyped format, ?untyped options) -> untyped
+        def init_translations: -> untyped
+        def translations: -> Hash[untyped, untyped]
+        def namespace_lookup?: (untyped result, untyped options) -> bool
+
+        private
+        def _deep_merge: (Hash[untyped, untyped] hash, Hash[untyped, untyped] other_hash) -> Hash[untyped, untyped]
+      end
+    end
+
+    module Fallbacks
+      def translate: (untyped locale, untyped key, ?untyped options) -> untyped
+      def resolve_entry: (untyped locale, untyped object, untyped subject, ?untyped options) -> untyped
+      def extract_non_symbol_default!: (untyped options) -> untyped
+      def exists?: (untyped locale, untyped key, ?untyped options) -> bool
+
+      private
+      def on_fallback: (untyped _original_locale, untyped _fallback_locale, untyped _key, untyped _optoins) -> untyped
+    end
+
+    module Flatten
+      SEPARATOR_ESCAPE_CHAR: String
+      FLATTEN_SEPARATOR: String
+
+      def self.normalize_flat_keys: (untyped locale, untyped key, untyped scope, untyped separator) -> String
+      def self.escape_default_separator: (untyped key) -> String
+      def normalize_flat_keys: (untyped locale, untyped key, untyped scope, untyped separator) -> String
+      def links: -> untyped
+      def flatten_keys: (Hash[untyped, untyped] hash, untyped escape, ?untyped? prev_key) { (untyped, untyped) -> void } -> untyped
+      def flatten_translations: (untyped locale, untyped data, untyped escape, untyped subtree) -> Hash[untyped, untyped]
+      def store_link: (untyped locale, String key, untyped link) -> String
+      def resolve_link: (untyped locale, untyped key) -> String
+      def find_link: (untyped locale, String key) -> [untyped, untyped]?
+      def escape_default_separator: (untyped key) -> untyped
+    end
+
+    module Gettext
+      def load_po: (String filename) -> [Hash[Symbol, untyped], false]
+      def parse: (String filename) -> untyped
+      def normalize: (Symbol locale, untyped data) -> untyped
+      def normalize_pluralization: (Symbol locale, String key, untyped value) -> [String, Hash[untyped, untyped]]
+
+      class PoData < Hash[untyped, untyped]
+        def set_comment: (untyped msgid_or_sym, untyped comment) -> void
+      end
+    end
+
+    module InterpolationCompiler
+      def interpolate: (untyped locale, untyped string, untyped values) -> untyped
+      def store_translations: (untyped locale, untyped data, ?untyped options) -> untyped
+      def compile_all_strings_in: (untyped data) -> untyped
+
+      module Compiler
+        TOKENIZER: Regexp
+        INTERPOLATION_SYNTAX_PATTERN: Regexp
+        extend Compiler
+
+        def compile_if_an_interpolation: (untyped string) -> untyped
+        def interpolated_str?: (untyped str) -> untyped
+        def tokenize: (String str) -> Array[String]
+        def compiled_interpolation_body: (String str) -> String
+        def handle_interpolation_token: (untyped interpolation, untyped matchdata) -> String
+        def compile_interpolation_token: (untyped key) -> String
+        def interpolate_or_raise_missing: (untyped key) -> String
+        def interpolate_key: (untyped key) -> String
+        def direct_key: (untyped key) -> String
+        def nil_key: (untyped key) -> String
+        def missing_key: (untyped key) -> String
+        def reserved_key: (untyped key) -> String
+        def escape_plain_str: (String str) -> String
+        def escape_key_sym: (untyped key) -> String
+      end
+    end
+
+    class KeyValue
+      include Implementation
+
+      module Implementation
+        attr_accessor store: untyped
+        def initialize: (untyped store, ?bool subtrees) -> void
+        def initialized?: -> bool
+        def store_translations: (untyped locale, untyped data, ?untyped options) -> untyped
+        def available_locales: -> Array[Symbol]
+        def translations: -> Hash[untyped, untyped]
+        def init_translations: -> void
+        def subtrees?: -> bool
+        def lookup: (untyped locale, untyped key, ?Array[untyped] scope, ?untyped options) -> untyped
+        def pluralize: (untyped locale, untyped entry, untyped count) -> untyped
+      end
+
+      class SubtreeProxy
+        def initialize: (untyped master_key, untyped store) -> void
+        def has_key?: (untyped key) -> bool
+        def []: (untyped key) -> untyped
+        def is_a?: (untyped klass) -> bool
+        alias kind_of? is_a?
+        def instance_of?: (untyped klass) -> bool
+        def nil?: -> bool
+        def inspect: -> String
+      end
+    end
+
+    module Metadata
+      def self.included: (untyped base) -> void
+      def translate: (untyped locale, untyped key, ?untyped options) -> untyped
+      def interpolate: (untyped locale, untyped entry, ?untyped values) -> untyped
+      def pluralize: (untyped locale, untyped entry, untyped count) -> untyped
+      def with_metadata: (Hash[Symbol, untyped] metadata) { -> untyped } -> untyped
+    end
+
+    class Simple
+      include Implementation
+
+      module Implementation
+        def initialized?: -> bool
+        def store_translations: (untyped locale, untyped data, ?untyped options) -> untyped
+        def available_locales: -> untyped
+        def reload!: -> untyped
+        def eager_load!: -> untyped
+        def translations: (?do_init: bool) -> untyped
+        def init_translations: -> true
+        def lookup: (untyped locale, untyped key, ?Array[untyped] scope, ?untyped options) -> untyped
+      end
+    end
+
+    module Transliterator
+      DEFAULT_REPLACEMENT_CHAR: String
+
+      def transliterate: (untyped locale, untyped string, ?untyped replacement) -> untyped
+      def self.get: (?untyped rule) -> (HashTransliterator | ProcTransliterator)
+
+      class ProcTransliterator
+        def initialize: (untyped rule) -> void
+        def transliterate: (untyped string, ?untyped replacement) -> untyped
+      end
+
+      class HashTransliterator
+        DEFAULT_APPROXIMATIONS: Hash[String, String]
+
+        def initialize: (?untyped rule) -> void
+        def transliterate: (String string, ?untyped replacement) -> String
+
+        private
+        def approximations: -> Hash[untyped, untyped]
+        def add_default_approximations: -> Hash[String, String]
+        def add: (Hash[untyped, untyped] hash) -> untyped
+      end
+    end
+
+    module Memoize
+      def available_locales: -> untyped
+      def store_translations: (untyped locale, untyped data, ?untyped options) -> untyped
+      def reload!: -> untyped
+      def eager_load!: -> untyped
+      def lookup: (untyped locale, untyped key, ?untyped scope, ?untyped options) -> untyped
+      def memoized_lookup: -> untyped
+      def reset_memoizations!: (?untyped locale) -> untyped
+    end
+
+    class LazyLoadable
+      def initialize: (?lazy_load: bool) -> void
+      def initialized?: -> bool
+      def reload!: -> untyped
+      def eager_load!: -> untyped
+      def available_locales: -> untyped
+      def lookup: (untyped locale, untyped key, ?Array[untyped] scope, ?untyped options) -> untyped
+      def init_translations: -> void
+      def initialized_locales: -> Hash[untyped, untyped]
+
+      private
+      def lazy_load?: -> bool
+      def load_translations_and_collect_file_errors: (untyped files) -> Array[untyped]
+      def filenames_for_current_locale: -> untyped
+      def assert_file_named_correctly!: (untyped file, untyped translations) -> void
+
+      class FilenameIncorrect < StandardError
+        def initialize: (untyped file, Symbol? expected_locale, untyped unexpected_locales) -> void
+      end
+    end
+
+    class LocaleExtractor
+      def self.locale_from_path: (String path) -> Symbol?
+    end
+
+    module Pluralization
+      def pluralize: (untyped locale, untyped entry, untyped count) -> untyped
+      def pluralizers: -> Hash[untyped, untyped]
+      def pluralizer: (untyped locale) -> untyped
+    end
+  end
+end

data/.gem_rbs_collection/i18n/1.10/i18n.rbs

@@ -0,0 +1,117 @@
+module I18n
+  extend Base
+
+  RESERVED_KEYS: Array[Symbol]
+  DEFAULT_INTERPOLATION_PATTERNS: [Regexp]
+  INTERPOLATION_PATTERN: Regexp
+  VERSION: String
+
+  module Base
+    def config: -> I18n::Config
+    def config=: (I18n::Config value) -> I18n::Config
+
+    def locale: -> Symbol
+    def locale=: (untyped value) -> untyped
+    def backend: -> untyped
+    def backend=: (untyped value) -> untyped
+    def default_locale: -> Symbol
+    def default_locale=: (untyped value) -> untyped
+    def available_locales: -> Array[String | Symbol]
+    def available_locales=: (untyped value) -> untyped
+    def default_separator: -> String
+    def default_separator=: (String value) -> String
+    def exception_handler: -> untyped
+    def exception_handler=: (untyped value) -> untyped
+    def load_path: -> Array[untyped]
+    def load_path=: (untyped value) -> untyped
+    def enforce_available_locales: -> untyped
+    def enforce_available_locales=: (untyped value) -> untyped
+
+    def reload!: -> void
+    def eager_load!: -> void
+    def translate: (String | Symbol | Array[untyped] key, ?throw: bool throw, ?raise: bool raise, ?locale: untyped? locale, **untyped options) -> String
+    alias t translate
+    def translate!: (untyped key, **untyped options) -> String
+    alias t! translate!
+    def exists?: (untyped key, ?untyped? _locale, ?locale: untyped locale, **untyped options) -> bool
+    def transliterate: (untyped key, ?throw: bool, ?raise: bool, ?locale: untyped?, ?replacement: untyped?, **untyped) -> untyped
+    def localize: (untyped object, ?locale: untyped, ?format: untyped, **untyped) -> untyped
+    alias l localize
+    def with_locale: (?untyped? tmp_locale) { () -> untyped } -> untyped
+    def normalize_keys: (untyped locale, untyped key, untyped scope, ?untyped separator) -> Array[Symbol]
+    def locale_available?: (Symbol | String locale) -> bool
+    def enforce_available_locales!: (untyped locale) -> nil
+    def available_locales_initialized?: -> bool
+  end
+
+  class Config
+    def locale: -> Symbol
+    def locale=: (untyped locale) -> untyped
+    def backend: -> untyped
+    def backend=: (untyped backend) -> untyped
+    def default_locale: -> Symbol
+    def default_locale=: (untyped locale) -> untyped
+    def available_locales: -> Array[String | Symbol]
+    def available_locales_set: -> untyped
+    def available_locales=: (untyped locales) -> void
+    def available_locales_initialized?: -> bool
+    def clear_available_locales_set: -> void
+    def default_separator: -> String
+    def default_separator=: (String separator) -> String
+    def exception_handler: -> untyped
+    def exception_handler=: (untyped exception_handler) -> untyped
+    def missing_interpolation_argument_handler: -> untyped
+    def missing_interpolation_argument_handler=: (untyped exception_handler) -> untyped
+    def load_path: -> Array[untyped]
+    def load_path=: (untyped load_path) -> void
+    def enforce_available_locales: -> untyped
+    def enforce_available_locales=: (untyped enforce_available_locales) -> untyped
+    def interpolation_patterns: -> untyped
+    def interpolation_patterns=: (untyped interpolation_patterns) -> untyped
+  end
+
+  module Utils
+    def self.except: (Hash[untyped, untyped] hash, *untyped keys) -> Hash[untyped, untyped]
+                   | (Hash[untyped, untyped] hash, *untyped keys) -> Hash[untyped, untyped]
+    def self.deep_merge: (Hash[untyped, untyped] hash, Hash[untyped, untyped] other_hash) -> Hash[untyped, untyped]
+    def self.deep_merge!: (untyped hash, untyped other_hash) -> Hash[untyped, untyped]
+    def self.deep_symbolize_keys: (Hash[untyped, untyped] hash) -> Hash[Symbol, untyped]
+    def self.deep_symbolize_keys_in_object: (untyped value) -> untyped
+  end
+
+  class ArgumentError < ::ArgumentError
+  end
+
+  class Disabled < ArgumentError
+  end
+
+  class InvalidLocale < ArgumentError
+  end
+
+  class InvalidLocaleData < ArgumentError
+  end
+
+  class MissingTranslation < ArgumentError
+  end
+
+  class MissingTranslationData < ArgumentError
+  end
+
+  class InvalidPluralizationData < ArgumentError
+  end
+
+  class MissingInterpolationArgument < ArgumentError
+  end
+
+  class ReservedInterpolationKey < ArgumentError
+  end
+
+  class UnknownFileType < ArgumentError
+  end
+
+  class UnsupportedMethod < ArgumentError
+  end
+
+  class InvalidFilenames < ArgumentError
+  end
+end

data/.gem_rbs_collection/listen/3.2/.rbs_meta.yaml

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

data/.gem_rbs_collection/listen/3.2/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