packwerk 1.1.2 → 1.1.3

Sign up to get free protection for your applications and to get access to all the features.
Files changed (74) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/ci.yml +14 -5
  3. data/.ruby-version +1 -1
  4. data/Gemfile +1 -1
  5. data/Gemfile.lock +127 -110
  6. data/README.md +7 -0
  7. data/dev.yml +1 -1
  8. data/gemfiles/Gemfile-rails-6-0 +22 -0
  9. data/lib/packwerk.rb +1 -0
  10. data/lib/packwerk/application_validator.rb +5 -5
  11. data/lib/packwerk/node_processor.rb +2 -1
  12. data/lib/packwerk/node_visitor.rb +1 -1
  13. data/lib/packwerk/version.rb +1 -1
  14. data/library.yml +1 -1
  15. data/service.yml +2 -2
  16. data/shipit.rubygems.yml +5 -1
  17. data/sorbet/rbi/gems/{actioncable@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → actioncable@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +56 -36
  18. data/sorbet/rbi/gems/{actionmailbox@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → actionmailbox@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +25 -28
  19. data/sorbet/rbi/gems/{actionmailer@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → actionmailer@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +43 -24
  20. data/sorbet/rbi/gems/{actionpack@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → actionpack@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +382 -284
  21. data/sorbet/rbi/gems/{actiontext@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → actiontext@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +76 -40
  22. data/sorbet/rbi/gems/{actionview@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → actionview@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +206 -195
  23. data/sorbet/rbi/gems/{activejob@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → activejob@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +64 -75
  24. data/sorbet/rbi/gems/{activemodel@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → activemodel@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +103 -56
  25. data/sorbet/rbi/gems/{activerecord@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → activerecord@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +1250 -898
  26. data/sorbet/rbi/gems/{activestorage@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → activestorage@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +92 -120
  27. data/sorbet/rbi/gems/{activesupport@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → activesupport@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +292 -193
  28. data/sorbet/rbi/gems/{ast@2.4.1.rbi → ast@2.4.2.rbi} +2 -1
  29. data/sorbet/rbi/gems/{better_html@1.0.15.rbi → better_html@1.0.16.rbi} +2 -2
  30. data/sorbet/rbi/gems/{concurrent-ruby@1.1.6.rbi → concurrent-ruby@1.1.8.rbi} +12 -9
  31. data/sorbet/rbi/gems/{erubi@1.9.0.rbi → erubi@1.10.0.rbi} +3 -1
  32. data/sorbet/rbi/gems/{i18n@1.8.2.rbi → i18n@1.8.10.rbi} +19 -52
  33. data/sorbet/rbi/gems/{loofah@2.5.0.rbi → loofah@2.9.0.rbi} +3 -1
  34. data/sorbet/rbi/gems/marcel@1.0.0.rbi +70 -0
  35. data/sorbet/rbi/gems/{mini_mime@1.0.2.rbi → mini_mime@1.0.3.rbi} +6 -6
  36. data/sorbet/rbi/gems/{mini_portile2@2.4.0.rbi → minitest-focus@1.2.1.rbi} +2 -2
  37. data/sorbet/rbi/gems/{minitest@5.14.0.rbi → minitest@5.14.4.rbi} +31 -29
  38. data/sorbet/rbi/gems/{mocha@1.11.2.rbi → mocha@1.12.0.rbi} +25 -36
  39. data/sorbet/rbi/gems/{nio4r@2.5.2.rbi → nio4r@2.5.7.rbi} +21 -20
  40. data/sorbet/rbi/gems/{nokogiri@1.10.9.rbi → nokogiri@1.11.2.rbi} +193 -154
  41. data/sorbet/rbi/gems/{parallel@1.19.1.rbi → parallel@1.20.1.rbi} +1 -1
  42. data/sorbet/rbi/gems/parlour@6.0.0.rbi +1272 -0
  43. data/sorbet/rbi/gems/{parser@2.7.1.4.rbi → parser@3.0.0.0.rbi} +287 -174
  44. data/sorbet/rbi/gems/{pry@0.13.1.rbi → pry@0.14.0.rbi} +1 -1
  45. data/sorbet/rbi/gems/racc@1.5.2.rbi +57 -0
  46. data/sorbet/rbi/gems/{rack@2.2.2.rbi → rack@2.2.3.rbi} +23 -35
  47. data/sorbet/rbi/gems/{rails@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → rails@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +1 -1
  48. data/sorbet/rbi/gems/{railties@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → railties@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi} +132 -121
  49. data/sorbet/rbi/gems/{rake@13.0.1.rbi → rake@13.0.3.rbi} +16 -20
  50. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +8 -0
  51. data/sorbet/rbi/gems/rubocop-ast@1.4.1.rbi +8 -0
  52. data/sorbet/rbi/gems/{rubocop-performance@1.5.2.rbi → rubocop-performance@1.10.2.rbi} +1 -1
  53. data/sorbet/rbi/gems/{rubocop-shopify@1.0.2.rbi → rubocop-shopify@2.0.1.rbi} +1 -1
  54. data/sorbet/rbi/gems/{rubocop-sorbet@0.3.7.rbi → rubocop-sorbet@0.6.1.rbi} +1 -1
  55. data/sorbet/rbi/gems/{rubocop@0.82.0.rbi → rubocop@1.12.0.rbi} +1 -1
  56. data/sorbet/rbi/gems/{ruby-progressbar@1.10.1.rbi → ruby-progressbar@1.11.0.rbi} +1 -1
  57. data/sorbet/rbi/gems/spoom@1.1.0.rbi +1061 -0
  58. data/sorbet/rbi/gems/{spring@2.1.0.rbi → spring@2.1.1.rbi} +7 -7
  59. data/sorbet/rbi/gems/{sprockets-rails@3.2.1.rbi → sprockets-rails@3.2.2.rbi} +88 -68
  60. data/sorbet/rbi/gems/{sprockets@4.0.0.rbi → sprockets@4.0.2.rbi} +8 -7
  61. data/sorbet/rbi/gems/{tapioca@0.4.5.rbi → tapioca@0.4.19.rbi} +109 -24
  62. data/sorbet/rbi/gems/{thor@1.0.1.rbi → thor@1.1.0.rbi} +16 -15
  63. data/sorbet/rbi/gems/{tzinfo@2.0.2.rbi → tzinfo@2.0.4.rbi} +21 -2
  64. data/sorbet/rbi/gems/{unicode-display_width@1.7.0.rbi → unicode-display_width@2.0.0.rbi} +1 -1
  65. data/sorbet/rbi/gems/{websocket-driver@0.7.1.rbi → websocket-driver@0.7.3.rbi} +29 -29
  66. data/sorbet/rbi/gems/{websocket-extensions@0.1.4.rbi → websocket-extensions@0.1.5.rbi} +2 -2
  67. data/sorbet/rbi/gems/zeitwerk@2.4.2.rbi +177 -0
  68. metadata +54 -52
  69. data/sorbet/rbi/gems/jaro_winkler@1.5.4.rbi +0 -8
  70. data/sorbet/rbi/gems/marcel@0.3.3.rbi +0 -30
  71. data/sorbet/rbi/gems/mimemagic@0.3.5.rbi +0 -47
  72. data/sorbet/rbi/gems/parlour@4.0.1.rbi +0 -561
  73. data/sorbet/rbi/gems/spoom@1.0.4.rbi +0 -418
  74. data/sorbet/rbi/gems/zeitwerk@2.3.0.rbi +0 -8
@@ -1,6 +1,6 @@
1
1
  # DO NOT EDIT MANUALLY
2
2
  # This is an autogenerated file for types exported from the `activestorage` gem.
3
- # Please instead update this file by running `dev typecheck update`.
3
+ # Please instead update this file by running `bin/tapioca sync`.
4
4
 
5
5
  # typed: true
6
6
 
@@ -27,6 +27,8 @@ module ActiveStorage
27
27
  def queues=(val); end
28
28
  def replace_on_assign_to_many; end
29
29
  def replace_on_assign_to_many=(val); end
30
+ def resolve_model_to_route; end
31
+ def resolve_model_to_route=(val); end
30
32
  def routes_prefix; end
31
33
  def routes_prefix=(val); end
32
34
  def service_urls_expire_in; end
@@ -67,6 +69,8 @@ module ActiveStorage
67
69
  def railtie_routes_url_helpers(include_path_helpers = T.unsafe(nil)); end
68
70
  def replace_on_assign_to_many; end
69
71
  def replace_on_assign_to_many=(val); end
72
+ def resolve_model_to_route; end
73
+ def resolve_model_to_route=(val); end
70
74
  def routes_prefix; end
71
75
  def routes_prefix=(val); end
72
76
  def service_urls_expire_in; end
@@ -143,6 +147,7 @@ class ActiveStorage::Analyzer::VideoAnalyzer < ::ActiveStorage::Analyzer
143
147
 
144
148
  def angle; end
145
149
  def computed_height; end
150
+ def container; end
146
151
  def display_aspect_ratio; end
147
152
  def display_height_scale; end
148
153
  def duration; end
@@ -264,12 +269,16 @@ module ActiveStorage::Attached::Model
264
269
 
265
270
  def attachment_changes; end
266
271
  def changed_for_autosave?; end
267
- def reload(*_); end
272
+ def reload(*_arg0); end
273
+
274
+ private
275
+
276
+ def initialize_dup(*_arg0); end
268
277
  end
269
278
 
270
279
  module ActiveStorage::Attached::Model::ClassMethods
271
- def has_many_attached(name, dependent: T.unsafe(nil), service: T.unsafe(nil)); end
272
- def has_one_attached(name, dependent: T.unsafe(nil), service: T.unsafe(nil)); end
280
+ def has_many_attached(name, dependent: T.unsafe(nil), service: T.unsafe(nil), strict_loading: T.unsafe(nil)); end
281
+ def has_one_attached(name, dependent: T.unsafe(nil), service: T.unsafe(nil), strict_loading: T.unsafe(nil)); end
273
282
 
274
283
  private
275
284
 
@@ -292,32 +301,36 @@ class ActiveStorage::Attached::One < ::ActiveStorage::Attached
292
301
  def write_attachment(attachment); end
293
302
  end
294
303
 
295
- class ActiveStorage::Attachment < ::ActiveRecord::Base
304
+ class ActiveStorage::Attachment < ::ActiveStorage::Record
296
305
  def autosave_associated_records_for_blob(*args); end
297
306
  def autosave_associated_records_for_record(*args); end
298
307
  def method_missing(method, *args, &block); end
299
308
  def purge; end
300
309
  def purge_later; end
310
+ def signed_id(*_arg0, &_arg1); end
311
+ def validate_associated_records_for_blob(*args); end
312
+ def variant(transformations); end
301
313
 
302
314
  private
303
315
 
304
316
  def analyze_blob_later; end
305
317
  def dependent; end
306
- def identify_blob; end
307
318
  def mirror_blob_later; end
308
319
  def purge_dependent_blob_later; end
309
320
  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
321
+ def variants; end
310
322
 
311
323
  class << self
312
324
  def __callbacks; end
313
325
  def _reflections; end
314
326
  def _validators; end
315
- def attribute_type_decorations; end
316
327
  def defined_enums; end
317
328
  end
318
329
  end
319
330
 
320
331
  class ActiveStorage::BaseController < ::ActionController::Base
332
+ include(::ActionController::Live)
333
+ include(::ActiveStorage::Streaming)
321
334
  include(::ActiveStorage::SetCurrent)
322
335
 
323
336
 
@@ -327,55 +340,17 @@ class ActiveStorage::BaseController < ::ActionController::Base
327
340
 
328
341
  class << self
329
342
  def __callbacks; end
330
- def _helpers; end
343
+ def etag_with_template_digest; end
331
344
  def middleware_stack; end
332
345
  end
333
346
  end
334
347
 
335
- module ActiveStorage::BaseController::HelperMethods
336
- include(::ActionController::Base::HelperMethods)
337
- end
338
-
339
348
  class ActiveStorage::BaseJob < ::ActiveJob::Base
340
349
  end
341
350
 
342
- class ActiveStorage::Blob < ::ActiveRecord::Base
343
- include(::ActiveStorage::Blob::Analyzable)
344
- include(::ActiveStorage::Blob::Identifiable)
345
- include(::ActiveStorage::Blob::Representable)
346
-
347
- def after_add_for_variant_records; end
348
- def after_add_for_variant_records=(_); end
349
- def after_add_for_variant_records?; end
350
- def after_remove_for_variant_records; end
351
- def after_remove_for_variant_records=(_); end
352
- def after_remove_for_variant_records?; end
353
- def autosave_associated_records_for_variant_records(*args); end
354
- def before_add_for_variant_records; end
355
- def before_add_for_variant_records=(_); end
356
- def before_add_for_variant_records?; end
357
- def before_remove_for_variant_records; end
358
- def before_remove_for_variant_records=(_); end
359
- def before_remove_for_variant_records?; end
360
- def validate_associated_records_for_variant_records(*args); end
361
-
351
+ class ActiveStorage::Blob < ::ActiveStorage::Record
362
352
  class << self
363
- def __callbacks; end
364
- def _reflections; end
365
353
  def _validators; end
366
- def after_add_for_variant_records; end
367
- def after_add_for_variant_records=(value); end
368
- def after_add_for_variant_records?; end
369
- def after_remove_for_variant_records; end
370
- def after_remove_for_variant_records=(value); end
371
- def after_remove_for_variant_records?; end
372
- def attribute_type_decorations; end
373
- def before_add_for_variant_records; end
374
- def before_add_for_variant_records=(value); end
375
- def before_add_for_variant_records?; end
376
- def before_remove_for_variant_records; end
377
- def before_remove_for_variant_records=(value); end
378
- def before_remove_for_variant_records?; end
379
354
  def defined_enums; end
380
355
  end
381
356
  end
@@ -395,12 +370,12 @@ end
395
370
  module ActiveStorage::Blob::Identifiable
396
371
  def identified?; end
397
372
  def identify; end
373
+ def identify_without_saving; end
398
374
 
399
375
  private
400
376
 
401
377
  def download_identifiable_chunk; end
402
378
  def identify_content_type; end
403
- def update_service_metadata; end
404
379
  end
405
380
 
406
381
  module ActiveStorage::Blob::Representable
@@ -415,30 +390,12 @@ module ActiveStorage::Blob::Representable
415
390
 
416
391
  private
417
392
 
393
+ def default_variant_format; end
394
+ def default_variant_transformations; end
395
+ def format; end
418
396
  def variant_class; end
419
397
  end
420
398
 
421
- class ActiveStorage::BlobsController < ::ActiveStorage::BaseController
422
- include(::ActiveStorage::SetBlob)
423
-
424
- def show; end
425
-
426
- private
427
-
428
- def _layout(lookup_context, formats); end
429
-
430
- class << self
431
- def __callbacks; end
432
- def _helpers; end
433
- def middleware_stack; end
434
- end
435
- end
436
-
437
- module ActiveStorage::BlobsController::HelperMethods
438
- include(::ActionController::Base::HelperMethods)
439
- include(::ActiveStorage::BaseController::HelperMethods)
440
- end
441
-
442
399
  class ActiveStorage::Current < ::ActiveSupport::CurrentAttributes
443
400
  class << self
444
401
  def host; end
@@ -457,16 +414,10 @@ class ActiveStorage::DirectUploadsController < ::ActiveStorage::BaseController
457
414
 
458
415
  class << self
459
416
  def __callbacks; end
460
- def _helpers; end
461
417
  def middleware_stack; end
462
418
  end
463
419
  end
464
420
 
465
- module ActiveStorage::DirectUploadsController::HelperMethods
466
- include(::ActionController::Base::HelperMethods)
467
- include(::ActiveStorage::BaseController::HelperMethods)
468
- end
469
-
470
421
  class ActiveStorage::DiskController < ::ActiveStorage::BaseController
471
422
  include(::ActiveStorage::FileServer)
472
423
 
@@ -483,16 +434,10 @@ class ActiveStorage::DiskController < ::ActiveStorage::BaseController
483
434
 
484
435
  class << self
485
436
  def __callbacks; end
486
- def _helpers; end
487
437
  def middleware_stack; end
488
438
  end
489
439
  end
490
440
 
491
- module ActiveStorage::DiskController::HelperMethods
492
- include(::ActionController::Base::HelperMethods)
493
- include(::ActiveStorage::BaseController::HelperMethods)
494
- end
495
-
496
441
  class ActiveStorage::Downloader
497
442
  def initialize(service); end
498
443
 
@@ -528,7 +473,7 @@ class ActiveStorage::Filename
528
473
  def initialize(filename); end
529
474
 
530
475
  def <=>(other); end
531
- def as_json(*_); end
476
+ def as_json(*_arg0); end
532
477
  def base; end
533
478
  def extension; end
534
479
  def extension_with_delimiter; end
@@ -542,6 +487,23 @@ class ActiveStorage::Filename
542
487
  end
543
488
  end
544
489
 
490
+ class ActiveStorage::FixtureSet
491
+ include(::ActiveSupport::Testing::FileFixtures)
492
+ include(::ActiveRecord::SecureToken)
493
+ extend(::ActiveRecord::SecureToken::ClassMethods)
494
+
495
+ def file_fixture_path; end
496
+ def file_fixture_path?; end
497
+ def prepare(instance, **attributes); end
498
+
499
+ class << self
500
+ def blob(filename:, **attributes); end
501
+ def file_fixture_path; end
502
+ def file_fixture_path=(value); end
503
+ def file_fixture_path?; end
504
+ end
505
+ end
506
+
545
507
  class ActiveStorage::IntegrityError < ::ActiveStorage::Error
546
508
  end
547
509
 
@@ -580,7 +542,9 @@ class ActiveStorage::Preview
580
542
  def initialize(blob, variation_or_variation_key); end
581
543
 
582
544
  def blob; end
545
+ def download(&block); end
583
546
  def image; end
547
+ def key; end
584
548
  def processed; end
585
549
  def service_url(*args, &block); end
586
550
  def url(**options); end
@@ -598,6 +562,9 @@ end
598
562
  class ActiveStorage::Preview::UnprocessedError < ::StandardError
599
563
  end
600
564
 
565
+ class ActiveStorage::PreviewError < ::ActiveStorage::Error
566
+ end
567
+
601
568
  class ActiveStorage::Previewer
602
569
  def initialize(blob); end
603
570
 
@@ -670,6 +637,13 @@ class ActiveStorage::PurgeJob < ::ActiveStorage::BaseJob
670
637
  end
671
638
  end
672
639
 
640
+ class ActiveStorage::Record < ::ActiveRecord::Base
641
+ class << self
642
+ def _validators; end
643
+ def defined_enums; end
644
+ end
645
+ end
646
+
673
647
  module ActiveStorage::Reflection
674
648
  end
675
649
 
@@ -684,11 +658,16 @@ module ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods
684
658
  def reflect_on_attachment(attachment); end
685
659
  end
686
660
 
687
- class ActiveStorage::Reflection::HasManyAttachedReflection < ::ActiveRecord::Reflection::MacroReflection
661
+ class ActiveStorage::Reflection::HasAttachedReflection < ::ActiveRecord::Reflection::MacroReflection
662
+ def variant(name, transformations); end
663
+ def variants; end
664
+ end
665
+
666
+ class ActiveStorage::Reflection::HasManyAttachedReflection < ::ActiveStorage::Reflection::HasAttachedReflection
688
667
  def macro; end
689
668
  end
690
669
 
691
- class ActiveStorage::Reflection::HasOneAttachedReflection < ::ActiveRecord::Reflection::MacroReflection
670
+ class ActiveStorage::Reflection::HasOneAttachedReflection < ::ActiveStorage::Reflection::HasAttachedReflection
692
671
  def macro; end
693
672
  end
694
673
 
@@ -700,27 +679,6 @@ module ActiveStorage::Reflection::ReflectionExtension
700
679
  def reflection_class_for(macro); end
701
680
  end
702
681
 
703
- class ActiveStorage::RepresentationsController < ::ActiveStorage::BaseController
704
- include(::ActiveStorage::SetBlob)
705
-
706
- def show; end
707
-
708
- private
709
-
710
- def _layout(lookup_context, formats); end
711
-
712
- class << self
713
- def __callbacks; end
714
- def _helpers; end
715
- def middleware_stack; end
716
- end
717
- end
718
-
719
- module ActiveStorage::RepresentationsController::HelperMethods
720
- include(::ActionController::Base::HelperMethods)
721
- include(::ActiveStorage::BaseController::HelperMethods)
722
- end
723
-
724
682
  class ActiveStorage::Service
725
683
  extend(::ActiveSupport::Autoload)
726
684
 
@@ -731,7 +689,7 @@ class ActiveStorage::Service
731
689
  def exist?(key); end
732
690
  def headers_for_direct_upload(key, filename:, content_type:, content_length:, checksum:); end
733
691
  def name; end
734
- def name=(_); end
692
+ def name=(_arg0); end
735
693
  def open(*args, **options, &block); end
736
694
  def public?; end
737
695
  def update_metadata(key, **metadata); end
@@ -743,8 +701,8 @@ class ActiveStorage::Service
743
701
 
744
702
  def content_disposition_with(filename:, type: T.unsafe(nil)); end
745
703
  def instrument(operation, payload = T.unsafe(nil), &block); end
746
- def private_url(key, expires_in:, filename:, disposition:, content_type:, **_); end
747
- def public_url(key, **_); end
704
+ def private_url(key, expires_in:, filename:, disposition:, content_type:, **_arg5); end
705
+ def public_url(key, **_arg1); end
748
706
  def service_name; end
749
707
 
750
708
  class << self
@@ -794,6 +752,18 @@ module ActiveStorage::SetCurrent
794
752
  extend(::ActiveSupport::Concern)
795
753
  end
796
754
 
755
+ module ActiveStorage::Streaming
756
+ include(::ActionController::Live)
757
+ extend(::ActionController::Live::ClassMethods)
758
+
759
+
760
+ private
761
+
762
+ def send_blob_stream(blob, disposition: T.unsafe(nil)); end
763
+ end
764
+
765
+ ActiveStorage::Streaming::DEFAULT_BLOB_STREAMING_DISPOSITION = T.let(T.unsafe(nil), String)
766
+
797
767
  module ActiveStorage::Transformers
798
768
  extend(::ActiveSupport::Autoload)
799
769
  end
@@ -832,13 +802,15 @@ class ActiveStorage::Variant
832
802
  def initialize(blob, variation_or_variation_key); end
833
803
 
834
804
  def blob; end
835
- def content_type(*args, &block); end
836
- def filename(*args, &block); end
837
- def format(*args, &block); end
805
+ def content_type(*_arg0, &_arg1); end
806
+ def content_type_for_serving(*_arg0, &_arg1); end
807
+ def download(&block); end
808
+ def filename; end
809
+ def forced_disposition_for_serving; end
838
810
  def image; end
839
811
  def key; end
840
812
  def processed; end
841
- def service(*args, &block); end
813
+ def service(*_arg0, &_arg1); end
842
814
  def service_url(*args, &block); end
843
815
  def url(expires_in: T.unsafe(nil), disposition: T.unsafe(nil)); end
844
816
  def variation; end
@@ -847,20 +819,15 @@ class ActiveStorage::Variant
847
819
 
848
820
  def process; end
849
821
  def processed?; end
850
- def specification; end
851
- end
852
-
853
- class ActiveStorage::Variant::Specification < ::OpenStruct
854
822
  end
855
823
 
856
- class ActiveStorage::VariantRecord < ::ActiveRecord::Base
824
+ class ActiveStorage::VariantRecord < ::ActiveStorage::Record
857
825
  def autosave_associated_records_for_blob(*args); end
858
826
 
859
827
  class << self
860
828
  def __callbacks; end
861
829
  def _reflections; end
862
830
  def _validators; end
863
- def attribute_type_decorations; end
864
831
  def defined_enums; end
865
832
  end
866
833
  end
@@ -869,12 +836,14 @@ class ActiveStorage::VariantWithRecord
869
836
  def initialize(blob, variation); end
870
837
 
871
838
  def blob; end
839
+ def download(*_arg0, &_arg1); end
872
840
  def image; end
841
+ def key(*_arg0, &_arg1); end
873
842
  def process; end
874
843
  def processed; end
875
844
  def processed?; end
876
845
  def service_url(*args, &block); end
877
- def url(**options); end
846
+ def url(*_arg0, &_arg1); end
878
847
  def variation; end
879
848
 
880
849
  private
@@ -887,9 +856,12 @@ end
887
856
  class ActiveStorage::Variation
888
857
  def initialize(transformations); end
889
858
 
859
+ def content_type; end
860
+ def default_to(defaults); end
890
861
  def digest; end
862
+ def format; end
891
863
  def key; end
892
- def transform(file, format: T.unsafe(nil), &block); end
864
+ def transform(file, &block); end
893
865
  def transformations; end
894
866
 
895
867
  private
@@ -1,6 +1,6 @@
1
1
  # DO NOT EDIT MANUALLY
2
2
  # This is an autogenerated file for types exported from the `activesupport` gem.
3
- # Please instead update this file by running `dev typecheck update`.
3
+ # Please instead update this file by running `bin/tapioca sync`.
4
4
 
5
5
  # typed: false
6
6
 
@@ -12,23 +12,28 @@ module ActiveSupport
12
12
  def parse_json_times=(val); end
13
13
  def test_order; end
14
14
  def test_order=(val); end
15
+ def test_parallelization_disabled; end
16
+ def test_parallelization_disabled=(val); end
15
17
 
16
18
  class << self
19
+ def disable_test_parallelization!; end
17
20
  def eager_load!; end
18
- def escape_html_entities_in_json(*args, &block); end
21
+ def escape_html_entities_in_json(*_arg0, &_arg1); end
19
22
  def escape_html_entities_in_json=(arg); end
20
23
  def gem_version; end
21
- def json_encoder(*args, &block); end
24
+ def json_encoder(*_arg0, &_arg1); end
22
25
  def json_encoder=(arg); end
23
26
  def parse_json_times; end
24
27
  def parse_json_times=(val); end
25
28
  def test_order; end
26
29
  def test_order=(val); end
27
- def time_precision(*args, &block); end
30
+ def test_parallelization_disabled; end
31
+ def test_parallelization_disabled=(val); end
32
+ def time_precision(*_arg0, &_arg1); end
28
33
  def time_precision=(arg); end
29
34
  def to_time_preserves_timezone; end
30
35
  def to_time_preserves_timezone=(value); end
31
- def use_standard_json_time_format(*args, &block); end
36
+ def use_standard_json_time_format(*_arg0, &_arg1); end
32
37
  def use_standard_json_time_format=(arg); end
33
38
  def utc_to_local_returns_utc_offset_times; end
34
39
  def utc_to_local_returns_utc_offset_times=(value); end
@@ -119,14 +124,14 @@ module ActiveSupport::Cache
119
124
  end
120
125
 
121
126
  class ActiveSupport::Cache::Entry
122
- def initialize(value, compress: T.unsafe(nil), compress_threshold: T.unsafe(nil), version: T.unsafe(nil), expires_in: T.unsafe(nil), **_); end
127
+ def initialize(value, compress: T.unsafe(nil), compress_threshold: T.unsafe(nil), version: T.unsafe(nil), expires_in: T.unsafe(nil), **_arg5); end
123
128
 
129
+ def bytesize; end
124
130
  def dup_value!; end
125
131
  def expired?; end
126
132
  def expires_at; end
127
133
  def expires_at=(value); end
128
134
  def mismatched?(version); end
129
- def size; end
130
135
  def value; end
131
136
  def version; end
132
137
 
@@ -142,10 +147,9 @@ ActiveSupport::Cache::Entry::DEFAULT_COMPRESS_LIMIT = T.let(T.unsafe(nil), Integ
142
147
  class ActiveSupport::Cache::FileStore < ::ActiveSupport::Cache::Store
143
148
  include(::ActiveSupport::Cache::Strategy::LocalCache)
144
149
 
145
- def initialize(cache_path, options = T.unsafe(nil)); end
150
+ def initialize(cache_path, **options); end
146
151
 
147
152
  def cache_path; end
148
- def delete_matched(matcher, options = T.unsafe(nil)); end
149
153
 
150
154
  private
151
155
 
@@ -185,7 +189,7 @@ class ActiveSupport::Cache::MemoryStore < ::ActiveSupport::Cache::Store
185
189
 
186
190
  private
187
191
 
188
- def cached_size(key, entry); end
192
+ def cached_size(key, payload); end
189
193
  def delete_entry(key, **options); end
190
194
  def modify_value(name, amount, options); end
191
195
  def read_entry(key, **options); end
@@ -196,18 +200,34 @@ class ActiveSupport::Cache::MemoryStore < ::ActiveSupport::Cache::Store
196
200
  end
197
201
  end
198
202
 
203
+ ActiveSupport::Cache::MemoryStore::DEFAULT_CODER = ActiveSupport::Cache::MemoryStore::DupCoder
204
+
205
+ module ActiveSupport::Cache::MemoryStore::DupCoder
206
+ class << self
207
+ def dump(entry); end
208
+ def load(entry); end
209
+ end
210
+ end
211
+
199
212
  ActiveSupport::Cache::MemoryStore::PER_ENTRY_OVERHEAD = T.let(T.unsafe(nil), Integer)
200
213
 
214
+ module ActiveSupport::Cache::NullCoder
215
+ class << self
216
+ def dump(entry); end
217
+ def load(payload); end
218
+ end
219
+ end
220
+
201
221
  class ActiveSupport::Cache::NullStore < ::ActiveSupport::Cache::Store
202
222
  include(::ActiveSupport::Cache::Strategy::LocalCache)
203
223
 
204
- def delete_matched(matcher, options = T.unsafe(nil)); end
205
-
206
224
  class << self
207
225
  def supports_cache_versioning?; end
208
226
  end
209
227
  end
210
228
 
229
+ ActiveSupport::Cache::OPTION_ALIASES = T.let(T.unsafe(nil), Hash)
230
+
211
231
  class ActiveSupport::Cache::Store
212
232
  def initialize(options = T.unsafe(nil)); end
213
233
 
@@ -237,6 +257,7 @@ class ActiveSupport::Cache::Store
237
257
 
238
258
  def delete_entry(key, **options); end
239
259
  def delete_multi_entries(entries, **options); end
260
+ def deserialize_entry(payload); end
240
261
  def expanded_key(key); end
241
262
  def expanded_version(key); end
242
263
  def get_entry_value(entry, name, options); end
@@ -246,10 +267,12 @@ class ActiveSupport::Cache::Store
246
267
  def merged_options(call_options); end
247
268
  def namespace_key(key, options = T.unsafe(nil)); end
248
269
  def normalize_key(key, options = T.unsafe(nil)); end
270
+ def normalize_options(options); end
249
271
  def normalize_version(key, options = T.unsafe(nil)); end
250
272
  def read_entry(key, **options); end
251
273
  def read_multi_entries(names, **options); end
252
274
  def save_block_result_to_cache(name, options); end
275
+ def serialize_entry(entry); end
253
276
  def write_entry(key, entry, **options); end
254
277
  def write_multi_entries(hash, **options); end
255
278
 
@@ -264,6 +287,8 @@ class ActiveSupport::Cache::Store
264
287
  end
265
288
  end
266
289
 
290
+ ActiveSupport::Cache::Store::DEFAULT_CODER = Marshal
291
+
267
292
  module ActiveSupport::Cache::Strategy
268
293
  end
269
294
 
@@ -271,6 +296,7 @@ module ActiveSupport::Cache::Strategy::LocalCache
271
296
  def cleanup(**options); end
272
297
  def clear(**options); end
273
298
  def decrement(name, amount = T.unsafe(nil), **options); end
299
+ def delete_matched(matcher, options = T.unsafe(nil)); end
274
300
  def increment(name, amount = T.unsafe(nil), **options); end
275
301
  def middleware; end
276
302
  def with_local_cache; end
@@ -366,17 +392,15 @@ class ActiveSupport::Callbacks::Callback
366
392
  def duplicates?(other); end
367
393
  def filter; end
368
394
  def kind; end
369
- def kind=(_); end
395
+ def kind=(_arg0); end
370
396
  def matches?(_kind, _filter); end
371
397
  def merge_conditional_options(chain, if_option:, unless_option:); end
372
398
  def name; end
373
- def name=(_); end
374
- def raw_filter; end
399
+ def name=(_arg0); end
375
400
 
376
401
  private
377
402
 
378
403
  def check_conditionals(conditionals); end
379
- def compute_identifier(filter); end
380
404
  def conditions_lambdas; end
381
405
 
382
406
  class << self
@@ -487,16 +511,15 @@ class ActiveSupport::Callbacks::Filters::Environment < ::Struct
487
511
  def value=(_); end
488
512
 
489
513
  class << self
490
- def [](*_); end
514
+ def [](*_arg0); end
491
515
  def inspect; end
492
516
  def members; end
493
- def new(*_); end
517
+ def new(*_arg0); end
494
518
  end
495
519
  end
496
520
 
497
521
  module ActiveSupport::CompareWithRange
498
522
  def ===(value); end
499
- def cover?(value); end
500
523
  def include?(value); end
501
524
  end
502
525
 
@@ -605,7 +628,7 @@ class ActiveSupport::CurrentAttributes
605
628
  def _reset_callbacks; end
606
629
  def _run_reset_callbacks(&block); end
607
630
  def attributes; end
608
- def attributes=(_); end
631
+ def attributes=(_arg0); end
609
632
  def reset; end
610
633
  def set(set_attributes); end
611
634
 
@@ -625,10 +648,10 @@ class ActiveSupport::CurrentAttributes
625
648
  def before_reset(&block); end
626
649
  def clear_all; end
627
650
  def instance; end
628
- def reset(*args, &block); end
651
+ def reset(*_arg0, &_arg1); end
629
652
  def reset_all; end
630
653
  def resets(&block); end
631
- def set(*args, &block); end
654
+ def set(*_arg0, &_arg1); end
632
655
 
633
656
  private
634
657
 
@@ -636,6 +659,7 @@ class ActiveSupport::CurrentAttributes
636
659
  def current_instances_key; end
637
660
  def generated_attribute_methods; end
638
661
  def method_missing(name, *args, &block); end
662
+ def respond_to_missing?(name, _); end
639
663
  end
640
664
  end
641
665
 
@@ -674,16 +698,12 @@ module ActiveSupport::Dependencies
674
698
  def loaded=(val); end
675
699
  def loading; end
676
700
  def loading=(val); end
677
- def log(message); end
678
- def logger; end
679
- def logger=(val); end
680
701
  def mark_for_unload(const_desc); end
681
702
  def mechanism; end
682
703
  def mechanism=(val); end
683
704
  def new_constants_in(*descs); end
684
705
  def qualified_const_defined?(path); end
685
706
  def qualified_name_for(mod, name); end
686
- def reference(klass); end
687
707
  def remove_constant(const); end
688
708
  def remove_unloadable_constants!; end
689
709
  def require_or_load(file_name, const_path = T.unsafe(nil)); end
@@ -691,15 +711,12 @@ module ActiveSupport::Dependencies
691
711
  def search_for_file(path_suffix); end
692
712
  def to_constant_name(desc); end
693
713
  def unhook!; end
694
- def verbose; end
695
- def verbose=(val); end
696
- def warnings_on_first_load; end
697
- def warnings_on_first_load=(val); end
698
714
  def will_unload?(const_desc); end
699
715
 
700
716
  private
701
717
 
702
718
  def real_mod_name(mod); end
719
+ def uninitialized_constant(qualified_name, const_name, receiver:); end
703
720
 
704
721
  class << self
705
722
  def _eager_load_paths; end
@@ -723,38 +740,13 @@ module ActiveSupport::Dependencies
723
740
  def loaded=(val); end
724
741
  def loading; end
725
742
  def loading=(val); end
726
- def logger; end
727
- def logger=(val); end
728
743
  def mechanism; end
729
744
  def mechanism=(val); end
730
745
  def run_interlock; end
731
746
  def unload_interlock; end
732
- def verbose; end
733
- def verbose=(val); end
734
- def warnings_on_first_load; end
735
- def warnings_on_first_load=(val); end
736
747
  end
737
748
  end
738
749
 
739
- module ActiveSupport::Dependencies::Blamable
740
- def blame_file!(file); end
741
- def blamed_files; end
742
- def copy_blame!(exc); end
743
- def describe_blame; end
744
- end
745
-
746
- class ActiveSupport::Dependencies::ClassCache
747
- def initialize; end
748
-
749
- def [](key); end
750
- def clear!; end
751
- def empty?; end
752
- def get(key); end
753
- def key?(key); end
754
- def safe_get(key); end
755
- def store(klass); end
756
- end
757
-
758
750
  class ActiveSupport::Dependencies::Interlock
759
751
  def initialize; end
760
752
 
@@ -798,8 +790,6 @@ module ActiveSupport::Dependencies::ModuleConstMissing
798
790
  end
799
791
  end
800
792
 
801
- ActiveSupport::Dependencies::Reference = T.let(T.unsafe(nil), ActiveSupport::Dependencies::ClassCache)
802
-
803
793
  class ActiveSupport::Dependencies::WatchStack
804
794
  include(::Enumerable)
805
795
 
@@ -865,26 +855,25 @@ class ActiveSupport::Deprecation
865
855
  def initialize(deprecation_horizon = T.unsafe(nil), gem_name = T.unsafe(nil)); end
866
856
 
867
857
  def deprecation_horizon; end
868
- def deprecation_horizon=(_); end
858
+ def deprecation_horizon=(_arg0); end
869
859
 
870
860
  class << self
871
- def allow(*args, &block); end
872
- def behavior(*args, &block); end
861
+ def allow(*_arg0, &_arg1); end
862
+ def behavior(*_arg0, &_arg1); end
873
863
  def behavior=(arg); end
874
- def debug(*args, &block); end
864
+ def debug(*_arg0, &_arg1); end
875
865
  def debug=(arg); end
876
- def deprecate_methods(*args, &block); end
877
- def deprecation_horizon(*args, &block); end
866
+ def deprecate_methods(*_arg0, &_arg1); end
867
+ def deprecation_horizon(*_arg0, &_arg1); end
878
868
  def deprecation_horizon=(arg); end
879
- def disallowed_behavior(*args, &block); end
869
+ def disallowed_behavior(*_arg0, &_arg1); end
880
870
  def disallowed_behavior=(arg); end
881
- def disallowed_warnings(*args, &block); end
871
+ def disallowed_warnings(*_arg0, &_arg1); end
882
872
  def disallowed_warnings=(arg); end
883
- def gem_name(*args, &block); end
873
+ def gem_name(*_arg0, &_arg1); end
884
874
  def gem_name=(arg); end
885
- def instance; end
886
- def silence(*args, &block); end
887
- def silenced(*args, &block); end
875
+ def silence(*_arg0, &_arg1); end
876
+ def silenced(*_arg0, &_arg1); end
888
877
  def silenced=(arg); end
889
878
  end
890
879
  end
@@ -893,7 +882,7 @@ module ActiveSupport::Deprecation::Behavior
893
882
  def behavior; end
894
883
  def behavior=(behavior); end
895
884
  def debug; end
896
- def debug=(_); end
885
+ def debug=(_arg0); end
897
886
  def disallowed_behavior; end
898
887
  def disallowed_behavior=(behavior); end
899
888
 
@@ -914,11 +903,11 @@ class ActiveSupport::Deprecation::DeprecatedConstantProxy < ::Module
914
903
  def initialize(old_const, new_const, deprecator = T.unsafe(nil), message: T.unsafe(nil)); end
915
904
 
916
905
  def class; end
917
- def hash(*args, &block); end
906
+ def hash(*_arg0, &_arg1); end
918
907
  def inspect; end
919
- def instance_methods(*args, &block); end
920
- def name(*args, &block); end
921
- def respond_to?(*args, &block); end
908
+ def instance_methods(*_arg0, &_arg1); end
909
+ def name(*_arg0, &_arg1); end
910
+ def respond_to?(*_arg0, &_arg1); end
922
911
 
923
912
  private
924
913
 
@@ -965,7 +954,7 @@ end
965
954
 
966
955
  module ActiveSupport::Deprecation::Disallowed
967
956
  def disallowed_warnings; end
968
- def disallowed_warnings=(_); end
957
+ def disallowed_warnings=(_arg0); end
969
958
 
970
959
  private
971
960
 
@@ -999,10 +988,10 @@ module ActiveSupport::Deprecation::Reporting
999
988
  def allow(allowed_warnings = T.unsafe(nil), if: T.unsafe(nil), &block); end
1000
989
  def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end
1001
990
  def gem_name; end
1002
- def gem_name=(_); end
991
+ def gem_name=(_arg0); end
1003
992
  def silence(&block); end
1004
993
  def silenced; end
1005
- def silenced=(_); end
994
+ def silenced=(_arg0); end
1006
995
  def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end
1007
996
 
1008
997
  private
@@ -1024,12 +1013,14 @@ module ActiveSupport::DescendantsTracker
1024
1013
  def descendants; end
1025
1014
  def direct_descendants; end
1026
1015
  def inherited(base); end
1016
+ def subclasses; end
1027
1017
 
1028
1018
  class << self
1029
1019
  def clear; end
1030
1020
  def descendants(klass); end
1031
1021
  def direct_descendants(klass); end
1032
1022
  def store_inherited(klass, descendant); end
1023
+ def subclasses(klass); end
1033
1024
 
1034
1025
  private
1035
1026
 
@@ -1082,6 +1073,13 @@ class ActiveSupport::Duration
1082
1073
  def eql?(other); end
1083
1074
  def from_now(time = T.unsafe(nil)); end
1084
1075
  def hash; end
1076
+ def in_days; end
1077
+ def in_hours; end
1078
+ def in_minutes; end
1079
+ def in_months; end
1080
+ def in_seconds; end
1081
+ def in_weeks; end
1082
+ def in_years; end
1085
1083
  def init_with(coder); end
1086
1084
  def inspect; end
1087
1085
  def instance_of?(klass); end
@@ -1089,13 +1087,13 @@ class ActiveSupport::Duration
1089
1087
  def iso8601(precision: T.unsafe(nil)); end
1090
1088
  def kind_of?(klass); end
1091
1089
  def parts; end
1092
- def parts=(_); end
1090
+ def parts=(_arg0); end
1093
1091
  def since(time = T.unsafe(nil)); end
1094
1092
  def to_i; end
1095
1093
  def to_s; end
1096
1094
  def until(time = T.unsafe(nil)); end
1097
1095
  def value; end
1098
- def value=(_); end
1096
+ def value=(_arg0); end
1099
1097
 
1100
1098
  private
1101
1099
 
@@ -1126,12 +1124,12 @@ class ActiveSupport::Duration::ISO8601Parser
1126
1124
  def initialize(string); end
1127
1125
 
1128
1126
  def mode; end
1129
- def mode=(_); end
1127
+ def mode=(_arg0); end
1130
1128
  def parse!; end
1131
1129
  def parts; end
1132
1130
  def scanner; end
1133
1131
  def sign; end
1134
- def sign=(_); end
1132
+ def sign=(_arg0); end
1135
1133
 
1136
1134
  private
1137
1135
 
@@ -1209,9 +1207,9 @@ class ActiveSupport::Duration::Scalar < ::Numeric
1209
1207
  def /(other); end
1210
1208
  def <=>(other); end
1211
1209
  def coerce(other); end
1212
- def to_f(*args, &block); end
1213
- def to_i(*args, &block); end
1214
- def to_s(*args, &block); end
1210
+ def to_f(*_arg0, &_arg1); end
1211
+ def to_i(*_arg0, &_arg1); end
1212
+ def to_s(*_arg0, &_arg1); end
1215
1213
  def value; end
1216
1214
 
1217
1215
  private
@@ -1232,9 +1230,9 @@ end
1232
1230
  class ActiveSupport::EncryptedConfiguration < ::ActiveSupport::EncryptedFile
1233
1231
  def initialize(config_path:, key_path:, env_key:, raise_if_missing_key:); end
1234
1232
 
1235
- def [](*args, &block); end
1233
+ def [](*_arg0, &_arg1); end
1236
1234
  def config; end
1237
- def fetch(*args, &block); end
1235
+ def fetch(*_arg0, &_arg1); end
1238
1236
  def method_missing(method, *args, &block); end
1239
1237
  def read; end
1240
1238
  def write(contents); end
@@ -1260,6 +1258,7 @@ class ActiveSupport::EncryptedFile
1260
1258
 
1261
1259
  private
1262
1260
 
1261
+ def check_key_length; end
1263
1262
  def decrypt(contents); end
1264
1263
  def encrypt(contents); end
1265
1264
  def encryptor; end
@@ -1269,12 +1268,17 @@ class ActiveSupport::EncryptedFile
1269
1268
  def writing(contents); end
1270
1269
 
1271
1270
  class << self
1271
+ def expected_key_length; end
1272
1272
  def generate_key; end
1273
1273
  end
1274
1274
  end
1275
1275
 
1276
1276
  ActiveSupport::EncryptedFile::CIPHER = T.let(T.unsafe(nil), String)
1277
1277
 
1278
+ class ActiveSupport::EncryptedFile::InvalidKeyLengthError < ::RuntimeError
1279
+ def initialize; end
1280
+ end
1281
+
1278
1282
  class ActiveSupport::EncryptedFile::MissingContentError < ::RuntimeError
1279
1283
  def initialize(content_path); end
1280
1284
  end
@@ -1320,7 +1324,7 @@ class ActiveSupport::ExecutionWrapper
1320
1324
  def _run_callbacks; end
1321
1325
  def _run_callbacks=(value); end
1322
1326
  def active; end
1323
- def active=(_); end
1327
+ def active=(_arg0); end
1324
1328
  def active?; end
1325
1329
  def inherited(other); end
1326
1330
  def register_hook(hook, outer: T.unsafe(nil)); end
@@ -1338,10 +1342,10 @@ class ActiveSupport::ExecutionWrapper::CompleteHook < ::Struct
1338
1342
  def hook=(_); end
1339
1343
 
1340
1344
  class << self
1341
- def [](*_); end
1345
+ def [](*_arg0); end
1342
1346
  def inspect; end
1343
1347
  def members; end
1344
- def new(*_); end
1348
+ def new(*_arg0); end
1345
1349
  end
1346
1350
  end
1347
1351
 
@@ -1353,10 +1357,10 @@ class ActiveSupport::ExecutionWrapper::RunHook < ::Struct
1353
1357
  def hook=(_); end
1354
1358
 
1355
1359
  class << self
1356
- def [](*_); end
1360
+ def [](*_arg0); end
1357
1361
  def inspect; end
1358
1362
  def members; end
1359
- def new(*_); end
1363
+ def new(*_arg0); end
1360
1364
  end
1361
1365
  end
1362
1366
 
@@ -1390,10 +1394,14 @@ module ActiveSupport::ForkTracker
1390
1394
  end
1391
1395
 
1392
1396
  module ActiveSupport::ForkTracker::CoreExt
1393
- def fork(*_); end
1397
+ def fork(*_arg0, &_arg1); end
1394
1398
  end
1395
1399
 
1396
1400
  module ActiveSupport::ForkTracker::CoreExtPrivate
1401
+
1402
+ private
1403
+
1404
+ def fork(*_arg0, &_arg1); end
1397
1405
  end
1398
1406
 
1399
1407
  module ActiveSupport::Gzip
@@ -1404,7 +1412,7 @@ module ActiveSupport::Gzip
1404
1412
  end
1405
1413
 
1406
1414
  class ActiveSupport::Gzip::Stream < ::StringIO
1407
- def initialize(*_); end
1415
+ def initialize(*_arg0); end
1408
1416
 
1409
1417
  def close; end
1410
1418
  end
@@ -1434,8 +1442,8 @@ class ActiveSupport::HashWithIndifferentAccess < ::Hash
1434
1442
  def merge(*hashes, &block); end
1435
1443
  def merge!(*other_hashes, &block); end
1436
1444
  def nested_under_indifferent_access; end
1437
- def regular_update(*_); end
1438
- def regular_writer(_, _); end
1445
+ def regular_update(*_arg0); end
1446
+ def regular_writer(_arg0, _arg1); end
1439
1447
  def reject(*args, &block); end
1440
1448
  def replace(other_hash); end
1441
1449
  def reverse_merge(other_hash); end
@@ -1533,6 +1541,7 @@ class ActiveSupport::Inflector::Inflections
1533
1541
 
1534
1542
  class << self
1535
1543
  def instance(locale = T.unsafe(nil)); end
1544
+ def instance_or_fallback(locale); end
1536
1545
  end
1537
1546
  end
1538
1547
 
@@ -1574,13 +1583,13 @@ ActiveSupport::JSON::DATE_REGEX = T.let(T.unsafe(nil), Regexp)
1574
1583
  module ActiveSupport::JSON::Encoding
1575
1584
  class << self
1576
1585
  def escape_html_entities_in_json; end
1577
- def escape_html_entities_in_json=(_); end
1586
+ def escape_html_entities_in_json=(_arg0); end
1578
1587
  def json_encoder; end
1579
- def json_encoder=(_); end
1588
+ def json_encoder=(_arg0); end
1580
1589
  def time_precision; end
1581
- def time_precision=(_); end
1590
+ def time_precision=(_arg0); end
1582
1591
  def use_standard_json_time_format; end
1583
- def use_standard_json_time_format=(_); end
1592
+ def use_standard_json_time_format=(_arg0); end
1584
1593
  end
1585
1594
  end
1586
1595
 
@@ -1600,6 +1609,11 @@ class ActiveSupport::KeyGenerator
1600
1609
  def initialize(secret, options = T.unsafe(nil)); end
1601
1610
 
1602
1611
  def generate_key(salt, key_size = T.unsafe(nil)); end
1612
+
1613
+ class << self
1614
+ def hash_digest_class; end
1615
+ def hash_digest_class=(klass); end
1616
+ end
1603
1617
  end
1604
1618
 
1605
1619
  module ActiveSupport::LazyLoadHooks
@@ -1625,6 +1639,7 @@ class ActiveSupport::LogSubscriber < ::ActiveSupport::Subscriber
1625
1639
  def finish(name, id, payload); end
1626
1640
  def info(progname = T.unsafe(nil), &block); end
1627
1641
  def logger; end
1642
+ def publish_event(event); end
1628
1643
  def start(name, id, payload); end
1629
1644
  def unknown(progname = T.unsafe(nil), &block); end
1630
1645
  def warn(progname = T.unsafe(nil), &block); end
@@ -1632,6 +1647,7 @@ class ActiveSupport::LogSubscriber < ::ActiveSupport::Subscriber
1632
1647
  private
1633
1648
 
1634
1649
  def color(text, color, bold = T.unsafe(nil)); end
1650
+ def log_exception(name, e); end
1635
1651
 
1636
1652
  class << self
1637
1653
  def colorize_logging; end
@@ -1639,7 +1655,11 @@ class ActiveSupport::LogSubscriber < ::ActiveSupport::Subscriber
1639
1655
  def flush_all!; end
1640
1656
  def log_subscribers; end
1641
1657
  def logger; end
1642
- def logger=(_); end
1658
+ def logger=(_arg0); end
1659
+
1660
+ private
1661
+
1662
+ def fetch_public_methods(subscriber, inherit_all); end
1643
1663
  end
1644
1664
  end
1645
1665
 
@@ -1698,7 +1718,6 @@ module ActiveSupport::LoggerThreadSafeLevel
1698
1718
  extend(::ActiveSupport::Concern)
1699
1719
 
1700
1720
  def add(severity, message = T.unsafe(nil), progname = T.unsafe(nil), &block); end
1701
- def after_initialize; end
1702
1721
  def debug?; end
1703
1722
  def error?; end
1704
1723
  def fatal?; end
@@ -1785,6 +1804,7 @@ class ActiveSupport::Messages::Metadata
1785
1804
 
1786
1805
  def fresh?; end
1787
1806
  def match?(purpose); end
1807
+ def parse_expires_at(expires_at); end
1788
1808
 
1789
1809
  class << self
1790
1810
  def verify(message, purpose); end
@@ -1849,17 +1869,16 @@ class ActiveSupport::Multibyte::Chars
1849
1869
 
1850
1870
  def initialize(string); end
1851
1871
 
1852
- def <=>(*args, &block); end
1853
- def =~(*args, &block); end
1854
- def acts_like_string?(*args, &block); end
1872
+ def <=>(*_arg0, &_arg1); end
1873
+ def =~(*_arg0, &_arg1); end
1874
+ def acts_like_string?(*_arg0, &_arg1); end
1855
1875
  def as_json(options = T.unsafe(nil)); end
1856
1876
  def compose; end
1857
1877
  def decompose; end
1858
1878
  def grapheme_length; end
1859
1879
  def limit(limit); end
1860
- def match?(*args, &block); end
1880
+ def match?(*_arg0, &_arg1); end
1861
1881
  def method_missing(method, *args, &block); end
1862
- def normalize(form = T.unsafe(nil)); end
1863
1882
  def reverse; end
1864
1883
  def reverse!(*args); end
1865
1884
  def slice!(*args); end
@@ -1876,10 +1895,6 @@ class ActiveSupport::Multibyte::Chars
1876
1895
 
1877
1896
  def chars(string); end
1878
1897
  def respond_to_missing?(method, include_private); end
1879
-
1880
- class << self
1881
- def consumes?(string); end
1882
- end
1883
1898
  end
1884
1899
 
1885
1900
  module ActiveSupport::Multibyte::Unicode
@@ -1889,23 +1904,13 @@ module ActiveSupport::Multibyte::Unicode
1889
1904
  def decompose(type, codepoints); end
1890
1905
  def default_normalization_form; end
1891
1906
  def default_normalization_form=(_); end
1892
- def downcase(string); end
1893
- def normalize(string, form = T.unsafe(nil)); end
1894
- def pack_graphemes(unpacked); end
1895
- def swapcase(string); end
1896
1907
  def tidy_bytes(string, force = T.unsafe(nil)); end
1897
- def unpack_graphemes(string); end
1898
- def upcase(string); end
1899
1908
 
1900
1909
  private
1901
1910
 
1902
1911
  def recode_windows1252_chars(string); end
1903
1912
  end
1904
1913
 
1905
- ActiveSupport::Multibyte::Unicode::NORMALIZATION_FORMS = T.let(T.unsafe(nil), Array)
1906
-
1907
- ActiveSupport::Multibyte::Unicode::NORMALIZATION_FORM_ALIASES = T.let(T.unsafe(nil), Hash)
1908
-
1909
1914
  ActiveSupport::Multibyte::Unicode::UNICODE_VERSION = T.let(T.unsafe(nil), String)
1910
1915
 
1911
1916
  module ActiveSupport::Notifications
@@ -1914,8 +1919,9 @@ module ActiveSupport::Notifications
1914
1919
  def instrumenter; end
1915
1920
  def monotonic_subscribe(pattern = T.unsafe(nil), callback = T.unsafe(nil), &block); end
1916
1921
  def notifier; end
1917
- def notifier=(_); end
1922
+ def notifier=(_arg0); end
1918
1923
  def publish(name, *args); end
1924
+ def publish_event(event); end
1919
1925
  def subscribe(pattern = T.unsafe(nil), callback = T.unsafe(nil), &block); end
1920
1926
  def subscribed(callback, pattern = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
1921
1927
  def unsubscribe(subscriber_or_name); end
@@ -1931,13 +1937,13 @@ class ActiveSupport::Notifications::Event
1931
1937
  def cpu_time; end
1932
1938
  def duration; end
1933
1939
  def end; end
1934
- def end=(ending); end
1935
1940
  def finish!; end
1936
1941
  def idle_time; end
1937
1942
  def name; end
1938
1943
  def parent_of?(event); end
1939
1944
  def payload; end
1940
- def payload=(_); end
1945
+ def payload=(_arg0); end
1946
+ def record; end
1941
1947
  def start!; end
1942
1948
  def time; end
1943
1949
  def transaction_id; end
@@ -1947,13 +1953,6 @@ class ActiveSupport::Notifications::Event
1947
1953
  def now; end
1948
1954
  def now_allocations; end
1949
1955
  def now_cpu; end
1950
-
1951
- class << self
1952
-
1953
- private
1954
-
1955
- def clock_gettime_supported?; end
1956
- end
1957
1956
  end
1958
1957
 
1959
1958
  class ActiveSupport::Notifications::Fanout
@@ -1967,6 +1966,7 @@ class ActiveSupport::Notifications::Fanout
1967
1966
  def lock; end
1968
1967
  def locked?; end
1969
1968
  def publish(name, *args); end
1969
+ def publish_event(event); end
1970
1970
  def start(name, id, payload); end
1971
1971
  def subscribe(pattern = T.unsafe(nil), callable = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
1972
1972
  def synchronize(&block); end
@@ -1987,15 +1987,16 @@ class ActiveSupport::Notifications::Fanout::Subscribers::AllMessages
1987
1987
  def initialize(delegate); end
1988
1988
 
1989
1989
  def finish(name, id, payload); end
1990
- def matches?(_); end
1990
+ def matches?(_arg0); end
1991
1991
  def publish(name, *args); end
1992
1992
  def start(name, id, payload); end
1993
1993
  def subscribed_to?(name); end
1994
- def unsubscribe!(*_); end
1994
+ def unsubscribe!(*_arg0); end
1995
1995
  end
1996
1996
 
1997
1997
  class ActiveSupport::Notifications::Fanout::Subscribers::EventObject < ::ActiveSupport::Notifications::Fanout::Subscribers::Evented
1998
1998
  def finish(name, id, payload); end
1999
+ def publish_event(event); end
1999
2000
  def start(name, id, payload); end
2000
2001
 
2001
2002
  private
@@ -2010,6 +2011,7 @@ class ActiveSupport::Notifications::Fanout::Subscribers::Evented
2010
2011
  def matches?(name); end
2011
2012
  def pattern; end
2012
2013
  def publish(name, *args); end
2014
+ def publish_event(event); end
2013
2015
  def start(name, id, payload); end
2014
2016
  def subscribed_to?(name); end
2015
2017
  def unsubscribe!(name); end
@@ -2051,10 +2053,12 @@ end
2051
2053
  class ActiveSupport::Notifications::Instrumenter
2052
2054
  def initialize(notifier); end
2053
2055
 
2056
+ def buffer; end
2054
2057
  def finish(name, payload); end
2055
2058
  def finish_with_state(listeners_state, name, payload); end
2056
2059
  def id; end
2057
2060
  def instrument(name, payload = T.unsafe(nil)); end
2061
+ def new_event(name, payload = T.unsafe(nil)); end
2058
2062
  def start(name, payload); end
2059
2063
 
2060
2064
  private
@@ -2062,6 +2066,13 @@ class ActiveSupport::Notifications::Instrumenter
2062
2066
  def unique_id; end
2063
2067
  end
2064
2068
 
2069
+ class ActiveSupport::Notifications::Instrumenter::Buffer
2070
+ def initialize(instrumenter); end
2071
+
2072
+ def flush; end
2073
+ def instrument(name, payload = T.unsafe(nil), &block); end
2074
+ end
2075
+
2065
2076
  module ActiveSupport::NumberHelper
2066
2077
  extend(::ActiveSupport::Autoload)
2067
2078
  extend(::ActiveSupport::NumberHelper)
@@ -2080,12 +2091,12 @@ class ActiveSupport::NumberHelper::NumberConverter
2080
2091
 
2081
2092
  def execute; end
2082
2093
  def namespace; end
2083
- def namespace=(_); end
2094
+ def namespace=(_arg0); end
2084
2095
  def namespace?; end
2085
2096
  def number; end
2086
2097
  def opts; end
2087
2098
  def validate_float; end
2088
- def validate_float=(_); end
2099
+ def validate_float=(_arg0); end
2089
2100
  def validate_float?; end
2090
2101
 
2091
2102
  private
@@ -2228,7 +2239,6 @@ class ActiveSupport::NumberHelper::RoundingHelper
2228
2239
 
2229
2240
  def absolute_precision(number); end
2230
2241
  def convert_to_decimal(number); end
2231
- def significant; end
2232
2242
  end
2233
2243
 
2234
2244
  class ActiveSupport::OptionMerger
@@ -2237,7 +2247,6 @@ class ActiveSupport::OptionMerger
2237
2247
 
2238
2248
  private
2239
2249
 
2240
- def invoke_method(method, arguments, options, &block); end
2241
2250
  def method_missing(method, *arguments, &block); end
2242
2251
  end
2243
2252
 
@@ -2254,11 +2263,12 @@ class ActiveSupport::OrderedOptions < ::Hash
2254
2263
  def [](key); end
2255
2264
  def []=(key, value); end
2256
2265
  def extractable_options?; end
2266
+ def inspect; end
2257
2267
  def method_missing(name, *args); end
2258
2268
 
2259
2269
  protected
2260
2270
 
2261
- def _get(_); end
2271
+ def _get(_arg0); end
2262
2272
 
2263
2273
  private
2264
2274
 
@@ -2327,12 +2337,12 @@ class ActiveSupport::Reloader < ::ActiveSupport::ExecutionWrapper
2327
2337
  def _run_class_unload_callbacks(&block); end
2328
2338
  def _run_prepare_callbacks(&block); end
2329
2339
  def check; end
2330
- def check=(_); end
2340
+ def check=(_arg0); end
2331
2341
  def check?; end
2332
2342
  def class_unload!(&block); end
2333
2343
  def complete!; end
2334
2344
  def executor; end
2335
- def executor=(_); end
2345
+ def executor=(_arg0); end
2336
2346
  def executor?; end
2337
2347
  def release_unload_lock!; end
2338
2348
  def require_unload_lock!; end
@@ -2386,7 +2396,7 @@ class ActiveSupport::SafeBuffer < ::String
2386
2396
  def initialize(str = T.unsafe(nil)); end
2387
2397
 
2388
2398
  def %(args); end
2389
- def *(*_); end
2399
+ def *(*_arg0); end
2390
2400
  def +(other); end
2391
2401
  def <<(value); end
2392
2402
  def [](*args); end
@@ -2423,6 +2433,8 @@ class ActiveSupport::SafeBuffer < ::String
2423
2433
  def rstrip(*args, &block); end
2424
2434
  def rstrip!(*args); end
2425
2435
  def safe_concat(value); end
2436
+ def scrub(*args, &block); end
2437
+ def scrub!(*args); end
2426
2438
  def slice(*args, &block); end
2427
2439
  def slice!(*args); end
2428
2440
  def squeeze(*args, &block); end
@@ -2450,7 +2462,7 @@ class ActiveSupport::SafeBuffer < ::String
2450
2462
 
2451
2463
  def html_escape_interpolated_argument(arg); end
2452
2464
  def initialize_copy(other); end
2453
- def original_concat(*_); end
2465
+ def original_concat(*_arg0); end
2454
2466
  def set_block_back_references(block, match_data); end
2455
2467
  end
2456
2468
 
@@ -2502,6 +2514,7 @@ class ActiveSupport::Subscriber
2502
2514
 
2503
2515
  def finish(name, id, payload); end
2504
2516
  def patterns; end
2517
+ def publish_event(event); end
2505
2518
  def start(name, id, payload); end
2506
2519
 
2507
2520
  private
@@ -2509,7 +2522,7 @@ class ActiveSupport::Subscriber
2509
2522
  def event_stack; end
2510
2523
 
2511
2524
  class << self
2512
- def attach_to(namespace, subscriber = T.unsafe(nil), notifier = T.unsafe(nil)); end
2525
+ def attach_to(namespace, subscriber = T.unsafe(nil), notifier = T.unsafe(nil), inherit_all: T.unsafe(nil)); end
2513
2526
  def detach_from(namespace, notifier = T.unsafe(nil)); end
2514
2527
  def method_added(event); end
2515
2528
  def subscribers; end
@@ -2517,6 +2530,7 @@ class ActiveSupport::Subscriber
2517
2530
  private
2518
2531
 
2519
2532
  def add_event_subscriber(event); end
2533
+ def fetch_public_methods(subscriber, inherit_all); end
2520
2534
  def find_attached_subscriber; end
2521
2535
  def invalid_event?(event); end
2522
2536
  def namespace; end
@@ -2537,10 +2551,10 @@ class ActiveSupport::SubscriberQueueRegistry
2537
2551
  end
2538
2552
 
2539
2553
  module ActiveSupport::TaggedLogging
2540
- def clear_tags!(*args, &block); end
2554
+ def clear_tags!(*_arg0, &_arg1); end
2541
2555
  def flush; end
2542
- def pop_tags(*args, &block); end
2543
- def push_tags(*args, &block); end
2556
+ def pop_tags(*_arg0, &_arg1); end
2557
+ def push_tags(*_arg0, &_arg1); end
2544
2558
  def tagged(*tags); end
2545
2559
 
2546
2560
  class << self
@@ -2560,7 +2574,7 @@ end
2560
2574
 
2561
2575
  module ActiveSupport::TaggedLogging::LocalTagStorage
2562
2576
  def current_tags; end
2563
- def current_tags=(_); end
2577
+ def current_tags=(_arg0); end
2564
2578
 
2565
2579
  class << self
2566
2580
  def extended(base); end
@@ -2769,16 +2783,16 @@ class ActiveSupport::Testing::SimpleStubs::Stub < ::Struct
2769
2783
  def original_method=(_); end
2770
2784
 
2771
2785
  class << self
2772
- def [](*_); end
2786
+ def [](*_arg0); end
2773
2787
  def inspect; end
2774
2788
  def members; end
2775
- def new(*_); end
2789
+ def new(*_arg0); end
2776
2790
  end
2777
2791
  end
2778
2792
 
2779
2793
  module ActiveSupport::Testing::TaggedLogging
2780
2794
  def before_setup; end
2781
- def tagged_logger=(_); end
2795
+ def tagged_logger=(_arg0); end
2782
2796
 
2783
2797
  private
2784
2798
 
@@ -2809,10 +2823,10 @@ class ActiveSupport::TimeWithZone
2809
2823
  def <=>(other); end
2810
2824
  def acts_like_time?; end
2811
2825
  def advance(options); end
2812
- def after?(_); end
2826
+ def after?(_arg0); end
2813
2827
  def ago(other); end
2814
2828
  def as_json(options = T.unsafe(nil)); end
2815
- def before?(_); end
2829
+ def before?(_arg0); end
2816
2830
  def between?(min, max); end
2817
2831
  def blank?; end
2818
2832
  def change(options); end
@@ -2946,7 +2960,7 @@ class ActiveSupport::TimeZone
2946
2960
  def all; end
2947
2961
  def clear; end
2948
2962
  def country_zones(country_code); end
2949
- def create(*_); end
2963
+ def create(*_arg0); end
2950
2964
  def find_tzinfo(name); end
2951
2965
  def new(name); end
2952
2966
  def seconds_to_utc_offset(seconds, colon = T.unsafe(nil)); end
@@ -3015,8 +3029,8 @@ module ActiveSupport::XmlMini
3015
3029
  def backend; end
3016
3030
  def backend=(name); end
3017
3031
  def depth; end
3018
- def depth=(_); end
3019
- def parse(*args, &block); end
3032
+ def depth=(_arg0); end
3033
+ def parse(*_arg0, &_arg1); end
3020
3034
  def rename_key(key, options = T.unsafe(nil)); end
3021
3035
  def to_tag(key, value, options); end
3022
3036
  def with_backend(name); end
@@ -3037,9 +3051,9 @@ ActiveSupport::XmlMini::FORMATTING = T.let(T.unsafe(nil), Hash)
3037
3051
 
3038
3052
  module ActiveSupport::XmlMini::FileLike
3039
3053
  def content_type; end
3040
- def content_type=(_); end
3054
+ def content_type=(_arg0); end
3041
3055
  def original_filename; end
3042
- def original_filename=(_); end
3056
+ def original_filename=(_arg0); end
3043
3057
  end
3044
3058
 
3045
3059
  ActiveSupport::XmlMini::PARSING = T.let(T.unsafe(nil), Hash)
@@ -3059,14 +3073,11 @@ module ActiveSupport::XmlMini_REXML
3059
3073
  def merge!(hash, key, value); end
3060
3074
  def merge_element!(hash, element, depth); end
3061
3075
  def merge_texts!(hash, element); end
3076
+ def require_rexml; end
3062
3077
  end
3063
3078
 
3064
3079
  ActiveSupport::XmlMini_REXML::CONTENT_KEY = T.let(T.unsafe(nil), String)
3065
3080
 
3066
- module ActiveSupport::MarshalWithAutoloading
3067
- def load(source, proc = T.unsafe(nil)); end
3068
- end
3069
-
3070
3081
  class Array
3071
3082
  include(::Enumerable)
3072
3083
  include(::JSON::Ext::Generator::GeneratorMethods::Array)
@@ -3082,13 +3093,9 @@ class Array
3082
3093
  def forty_two; end
3083
3094
  def fourth; end
3084
3095
  def from(position); end
3085
- def in_groups(number, fill_with = T.unsafe(nil)); end
3086
- def in_groups_of(number, fill_with = T.unsafe(nil)); end
3087
3096
  def including(*elements); end
3088
- def inquiry; end
3089
3097
  def second; end
3090
3098
  def second_to_last; end
3091
- def split(value = T.unsafe(nil)); end
3092
3099
  def sum(init = T.unsafe(nil), &block); end
3093
3100
  def third; end
3094
3101
  def third_to_last; end
@@ -3167,7 +3174,7 @@ class Date
3167
3174
  def beginning_of_week; end
3168
3175
  def beginning_of_week=(week_start); end
3169
3176
  def beginning_of_week_default; end
3170
- def beginning_of_week_default=(_); end
3177
+ def beginning_of_week_default=(_arg0); end
3171
3178
  def current; end
3172
3179
  def find_beginning_of_week!(week_start); end
3173
3180
  def tomorrow; end
@@ -3355,15 +3362,45 @@ Digest::UUID::URL_NAMESPACE = T.let(T.unsafe(nil), String)
3355
3362
 
3356
3363
  Digest::UUID::X500_NAMESPACE = T.let(T.unsafe(nil), String)
3357
3364
 
3365
+ module ERB::Util
3366
+
3367
+ private
3368
+
3369
+ def h(s); end
3370
+ def html_escape(s); end
3371
+ def html_escape_once(s); end
3372
+ def json_escape(s); end
3373
+ def unwrapped_html_escape(s); end
3374
+
3375
+ class << self
3376
+ def h(s); end
3377
+ def html_escape(s); end
3378
+ def html_escape_once(s); end
3379
+ def json_escape(s); end
3380
+ def unwrapped_html_escape(s); end
3381
+ end
3382
+ end
3383
+
3384
+ ERB::Util::HTML_ESCAPE = T.let(T.unsafe(nil), Hash)
3385
+
3386
+ ERB::Util::HTML_ESCAPE_ONCE_REGEXP = T.let(T.unsafe(nil), Regexp)
3387
+
3388
+ ERB::Util::JSON_ESCAPE = T.let(T.unsafe(nil), Hash)
3389
+
3390
+ ERB::Util::JSON_ESCAPE_REGEXP = T.let(T.unsafe(nil), Regexp)
3391
+
3358
3392
  module Enumerable
3359
3393
  def as_json(options = T.unsafe(nil)); end
3360
3394
  def compact_blank; end
3361
3395
  def exclude?(object); end
3362
3396
  def excluding(*elements); end
3397
+ def in_order_of(key, series); end
3363
3398
  def including(*elements); end
3364
3399
  def index_by; end
3365
3400
  def index_with(default = T.unsafe(nil)); end
3366
3401
  def many?; end
3402
+ def maximum(key); end
3403
+ def minimum(key); end
3367
3404
  def pick(*keys); end
3368
3405
  def pluck(*keys); end
3369
3406
  def sum(identity = T.unsafe(nil), &block); end
@@ -3371,8 +3408,6 @@ module Enumerable
3371
3408
  end
3372
3409
 
3373
3410
  class Exception
3374
- include(::ActiveSupport::Dependencies::Blamable)
3375
-
3376
3411
  def as_json(options = T.unsafe(nil)); end
3377
3412
  end
3378
3413
 
@@ -3410,7 +3445,6 @@ class Hash
3410
3445
  def deep_transform_keys!(&block); end
3411
3446
  def deep_transform_values(&block); end
3412
3447
  def deep_transform_values!(&block); end
3413
- def except(*keys); end
3414
3448
  def except!(*keys); end
3415
3449
  def extract!(*keys); end
3416
3450
  def extractable_options?; end
@@ -3451,6 +3485,8 @@ module I18n
3451
3485
  extend(::I18n::Base)
3452
3486
 
3453
3487
  class << self
3488
+ def fallbacks; end
3489
+ def fallbacks=(fallbacks); end
3454
3490
  def interpolate(string, values); end
3455
3491
  def interpolate_hash(string, values); end
3456
3492
  def new_double_nested_cache; end
@@ -3469,6 +3505,7 @@ I18n::RESERVED_KEYS_PATTERN = T.let(T.unsafe(nil), Regexp)
3469
3505
 
3470
3506
  class I18n::Railtie < ::Rails::Railtie
3471
3507
  class << self
3508
+ def forward_raise_on_missing_translations_config(app); end
3472
3509
  def include_fallbacks_module; end
3473
3510
  def init_fallbacks(fallbacks); end
3474
3511
  def initialize_i18n(app); end
@@ -3486,10 +3523,32 @@ class IO
3486
3523
  def as_json(options = T.unsafe(nil)); end
3487
3524
  end
3488
3525
 
3526
+ class IO::ConsoleMode
3527
+ def echo=(_arg0); end
3528
+ def raw(*_arg0); end
3529
+ def raw!(*_arg0); end
3530
+
3531
+ private
3532
+
3533
+ def initialize_copy(_arg0); end
3534
+ end
3535
+
3489
3536
  IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
3490
3537
 
3491
3538
  IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
3492
3539
 
3540
+ IO::PRIORITY = T.let(T.unsafe(nil), Integer)
3541
+
3542
+ IO::READABLE = T.let(T.unsafe(nil), Integer)
3543
+
3544
+ IO::WRITABLE = T.let(T.unsafe(nil), Integer)
3545
+
3546
+ class IPAddr
3547
+ include(::Comparable)
3548
+
3549
+ def as_json(options = T.unsafe(nil)); end
3550
+ end
3551
+
3493
3552
  class Integer < ::Numeric
3494
3553
  include(::JSON::Ext::Generator::GeneratorMethods::Integer)
3495
3554
 
@@ -3500,7 +3559,6 @@ class Integer < ::Numeric
3500
3559
  end
3501
3560
 
3502
3561
  module Kernel
3503
- def class_eval(*args, &block); end
3504
3562
 
3505
3563
  private
3506
3564
 
@@ -3518,14 +3576,9 @@ module Kernel
3518
3576
  end
3519
3577
 
3520
3578
  class LoadError < ::ScriptError
3521
- def is_missing?(location); end
3522
- end
3523
-
3524
- module LoggerSilence
3525
- extend(::ActiveSupport::Concern)
3579
+ include(::DidYouMean::Correctable)
3526
3580
 
3527
- include(::ActiveSupport::LoggerThreadSafeLevel)
3528
- include(::ActiveSupport::LoggerSilence)
3581
+ def is_missing?(location); end
3529
3582
  end
3530
3583
 
3531
3584
  class Method
@@ -3558,9 +3611,6 @@ class Module
3558
3611
  def module_parent; end
3559
3612
  def module_parent_name; end
3560
3613
  def module_parents; end
3561
- def parent; end
3562
- def parent_name; end
3563
- def parents; end
3564
3614
  def redefine_method(method, &block); end
3565
3615
  def redefine_singleton_method(method, &block); end
3566
3616
  def remove_possible_method(method); end
@@ -3580,7 +3630,7 @@ class Module
3580
3630
 
3581
3631
  class << self
3582
3632
  def attr_internal_naming_format; end
3583
- def attr_internal_naming_format=(_); end
3633
+ def attr_internal_naming_format=(_arg0); end
3584
3634
  end
3585
3635
  end
3586
3636
 
@@ -3603,6 +3653,10 @@ class NameError < ::StandardError
3603
3653
 
3604
3654
  def missing_name; end
3605
3655
  def missing_name?(name); end
3656
+
3657
+ private
3658
+
3659
+ def real_mod_name(mod); end
3606
3660
  end
3607
3661
 
3608
3662
  class NilClass
@@ -3611,8 +3665,8 @@ class NilClass
3611
3665
  def as_json(options = T.unsafe(nil)); end
3612
3666
  def blank?; end
3613
3667
  def to_param; end
3614
- def try(_method_name = T.unsafe(nil), *_); end
3615
- def try!(_method_name = T.unsafe(nil), *_); end
3668
+ def try(_method_name = T.unsafe(nil), *_arg1); end
3669
+ def try!(_method_name = T.unsafe(nil), *_arg1); end
3616
3670
  end
3617
3671
 
3618
3672
  class Numeric
@@ -3667,6 +3721,8 @@ class Object < ::BasicObject
3667
3721
  include(::ActiveSupport::ForkTracker::CoreExt)
3668
3722
  include(::ActiveSupport::ForkTracker::CoreExtPrivate)
3669
3723
  include(::Kernel)
3724
+ include(::ActiveSupport::ForkTracker::CoreExt)
3725
+ include(::ActiveSupport::ForkTracker::CoreExtPrivate)
3670
3726
  include(::JSON::Ext::Generator::GeneratorMethods::Object)
3671
3727
  include(::ActiveSupport::Tryable)
3672
3728
  include(::ActiveSupport::Dependencies::Loadable)
@@ -3697,6 +3753,10 @@ class Pathname
3697
3753
  def as_json(options = T.unsafe(nil)); end
3698
3754
  end
3699
3755
 
3756
+ class Process::Status
3757
+ def as_json(options = T.unsafe(nil)); end
3758
+ end
3759
+
3700
3760
  class Range
3701
3761
  include(::ActiveSupport::RangeWithFormat)
3702
3762
  include(::ActiveSupport::CompareWithRange)
@@ -3714,12 +3774,20 @@ class Regexp
3714
3774
  def multiline?; end
3715
3775
  end
3716
3776
 
3777
+ module Singleton
3778
+ mixes_in_class_methods(::Singleton::SingletonClassMethods)
3779
+
3780
+ def duplicable?; end
3781
+ end
3782
+
3783
+ Singleton::VERSION = T.let(T.unsafe(nil), String)
3784
+
3717
3785
  class String
3718
3786
  include(::Comparable)
3719
- include(::Colorize::InstanceMethods)
3720
3787
  include(::JSON::Ext::Generator::GeneratorMethods::String)
3721
- extend(::Colorize::ClassMethods)
3788
+ include(::Colorize::InstanceMethods)
3722
3789
  extend(::JSON::Ext::Generator::GeneratorMethods::String::Extend)
3790
+ extend(::Colorize::ClassMethods)
3723
3791
 
3724
3792
  def acts_like_string?; end
3725
3793
  def as_json(options = T.unsafe(nil)); end
@@ -3738,6 +3806,7 @@ class String
3738
3806
  def html_safe; end
3739
3807
  def humanize(capitalize: T.unsafe(nil), keep_id_suffix: T.unsafe(nil)); end
3740
3808
  def in_time_zone(zone = T.unsafe(nil)); end
3809
+ def inquiry; end
3741
3810
  def is_utf8?; end
3742
3811
  def last(limit = T.unsafe(nil)); end
3743
3812
  def mb_chars; end
@@ -3779,16 +3848,10 @@ Struct::HTMLElementDescription = Struct
3779
3848
 
3780
3849
  Struct::Passwd = Etc::Passwd
3781
3850
 
3782
- Struct::Tms = Process::Tms
3783
-
3784
3851
  class Symbol
3785
3852
  include(::Comparable)
3786
3853
 
3787
3854
  def as_json(options = T.unsafe(nil)); end
3788
- def end_with?(*suffixes); end
3789
- def ends_with?(*suffixes); end
3790
- def start_with?(*prefixes); end
3791
- def starts_with?(*prefixes); end
3792
3855
  end
3793
3856
 
3794
3857
  class Time
@@ -3852,8 +3915,8 @@ class Time
3852
3915
 
3853
3916
  class << self
3854
3917
  def ===(other); end
3855
- def at(*args); end
3856
- def at_with_coercion(*args); end
3918
+ def at(*args, **kwargs); end
3919
+ def at_with_coercion(*args, **kwargs); end
3857
3920
  def current; end
3858
3921
  def days_in_month(month, year = T.unsafe(nil)); end
3859
3922
  def days_in_year(year = T.unsafe(nil)); end
@@ -3864,7 +3927,7 @@ class Time
3864
3927
  def zone; end
3865
3928
  def zone=(time_zone); end
3866
3929
  def zone_default; end
3867
- def zone_default=(_); end
3930
+ def zone_default=(_arg0); end
3868
3931
  end
3869
3932
  end
3870
3933
 
@@ -3880,6 +3943,42 @@ class TrueClass
3880
3943
  def to_param; end
3881
3944
  end
3882
3945
 
3946
+ module URI
3947
+ include(::URI::RFC2396_REGEXP)
3948
+
3949
+ class << self
3950
+ def parser; end
3951
+ end
3952
+ end
3953
+
3954
+ class URI::File < ::URI::Generic
3955
+ def check_password(user); end
3956
+ def check_user(user); end
3957
+ def check_userinfo(user); end
3958
+ def set_host(v); end
3959
+ def set_password(v); end
3960
+ def set_port(v); end
3961
+ def set_user(v); end
3962
+ def set_userinfo(v); end
3963
+
3964
+ class << self
3965
+ def build(args); end
3966
+ end
3967
+ end
3968
+
3969
+ URI::File::COMPONENT = T.let(T.unsafe(nil), Array)
3970
+
3971
+ class URI::Generic
3972
+ include(::URI::RFC2396_REGEXP)
3973
+ include(::URI)
3974
+
3975
+ def as_json(options = T.unsafe(nil)); end
3976
+ end
3977
+
3978
+ URI::Parser = URI::RFC2396_Parser
3979
+
3980
+ URI::REGEXP = URI::RFC2396_REGEXP
3981
+
3883
3982
  class UnboundMethod
3884
3983
  include(::MethodSource::SourceLocation::UnboundMethodExtensions)
3885
3984
  include(::MethodSource::MethodExtensions)