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 `activerecord` 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
 
@@ -14,6 +14,9 @@ module ActiveRecord
14
14
  end
15
15
  end
16
16
 
17
+ class ActiveRecord::ActiveJobRequiredError < ::ActiveRecord::ActiveRecordError
18
+ end
19
+
17
20
  class ActiveRecord::ActiveRecordError < ::StandardError
18
21
  end
19
22
 
@@ -26,23 +29,14 @@ end
26
29
  class ActiveRecord::AdapterTimeout < ::ActiveRecord::QueryAborted
27
30
  end
28
31
 
29
- class ActiveRecord::AdvisoryLockBase < ::ActiveRecord::Base
30
- class << self
31
- def _internal?; end
32
- def _validators; end
33
- def attribute_type_decorations; end
34
- def defined_enums; end
35
- end
36
- end
37
-
38
32
  module ActiveRecord::Aggregations
39
- def reload(*_); end
33
+ def reload(*_arg0); end
40
34
 
41
35
  private
42
36
 
43
37
  def clear_aggregation_cache; end
44
38
  def init_internals; end
45
- def initialize_dup(*_); end
39
+ def initialize_dup(*_arg0); end
46
40
  end
47
41
 
48
42
  module ActiveRecord::Aggregations::ClassMethods
@@ -59,27 +53,37 @@ class ActiveRecord::AmbiguousSourceReflectionForThroughAssociation < ::ActiveRec
59
53
  end
60
54
 
61
55
  class ActiveRecord::AssociationNotFoundError < ::ActiveRecord::ConfigurationError
56
+ include(::DidYouMean::Correctable)
57
+
62
58
  def initialize(record = T.unsafe(nil), association_name = T.unsafe(nil)); end
59
+
60
+ def association_name; end
61
+ def record; end
62
+ end
63
+
64
+ class ActiveRecord::AssociationNotFoundError::Correction
65
+ def initialize(error); end
66
+
67
+ def corrections; end
63
68
  end
64
69
 
65
70
  class ActiveRecord::AssociationRelation < ::ActiveRecord::Relation
66
- def initialize(klass, association, **_); end
71
+ def initialize(klass, association, **_arg2); end
67
72
 
68
73
  def ==(other); end
69
- def build(attributes = T.unsafe(nil), &block); end
70
- def create(attributes = T.unsafe(nil), &block); end
71
- def create!(attributes = T.unsafe(nil), &block); end
72
74
  def insert(attributes, **kwargs); end
73
75
  def insert!(attributes, **kwargs); end
74
76
  def insert_all(attributes, **kwargs); end
75
77
  def insert_all!(attributes, **kwargs); end
76
- def new(attributes = T.unsafe(nil), &block); end
77
78
  def proxy_association; end
78
79
  def upsert(attributes, **kwargs); end
79
80
  def upsert_all(attributes, **kwargs); end
80
81
 
81
82
  private
82
83
 
84
+ def _create(attributes, &block); end
85
+ def _create!(attributes, &block); end
86
+ def _new(attributes, &block); end
83
87
  def exec_queries; end
84
88
  end
85
89
 
@@ -94,7 +98,7 @@ module ActiveRecord::Associations
94
98
 
95
99
  def association(name); end
96
100
  def association_cached?(name); end
97
- def reload(*_); end
101
+ def reload(*_arg0); end
98
102
 
99
103
  private
100
104
 
@@ -102,7 +106,7 @@ module ActiveRecord::Associations
102
106
  def association_instance_set(name, association); end
103
107
  def clear_association_cache; end
104
108
  def init_internals; end
105
- def initialize_dup(*_); end
109
+ def initialize_dup(*_arg0); end
106
110
 
107
111
  class << self
108
112
  def eager_load!; end
@@ -112,7 +116,7 @@ end
112
116
  class ActiveRecord::Associations::AliasTracker
113
117
  def initialize(connection, aliases); end
114
118
 
115
- def aliased_table_for(table_name, aliased_name, type_caster); end
119
+ def aliased_table_for(arel_table, table_name = T.unsafe(nil)); end
116
120
  def aliases; end
117
121
 
118
122
  private
@@ -120,7 +124,7 @@ class ActiveRecord::Associations::AliasTracker
120
124
  def truncate(name); end
121
125
 
122
126
  class << self
123
- def create(connection, initial_table, joins); end
127
+ def create(connection, initial_table, joins, aliases = T.unsafe(nil)); end
124
128
  def initial_count_for(connection, name, table_joins); end
125
129
  end
126
130
  end
@@ -140,7 +144,7 @@ class ActiveRecord::Associations::Association
140
144
  def loaded?; end
141
145
  def marshal_dump; end
142
146
  def marshal_load(data); end
143
- def options(*args, &block); end
147
+ def options(*_arg0, &_arg1); end
144
148
  def owner; end
145
149
  def reflection; end
146
150
  def reload(force = T.unsafe(nil)); end
@@ -159,20 +163,22 @@ class ActiveRecord::Associations::Association
159
163
 
160
164
  def association_scope; end
161
165
  def build_record(attributes); end
162
- def creation_attributes; end
166
+ def enqueue_destroy_association(options); end
163
167
  def find_target; end
164
168
  def find_target?; end
165
169
  def foreign_key_for?(record); end
166
170
  def foreign_key_present?; end
171
+ def inversable?(record); end
167
172
  def inverse_association_for(record); end
168
173
  def inverse_reflection_for(record); end
169
174
  def invertible_for?(record); end
175
+ def matches_foreign_key?(record); end
170
176
  def raise_on_type_mismatch!(record); end
171
177
  def scope_for_create; end
172
- def set_owner_attributes(record); end
173
178
  def skip_statement_cache?(scope); end
174
179
  def stale_state; end
175
180
  def target_scope; end
181
+ def violates_strict_loading?; end
176
182
  end
177
183
 
178
184
  class ActiveRecord::Associations::AssociationScope
@@ -226,7 +232,7 @@ class ActiveRecord::Associations::BelongsToAssociation < ::ActiveRecord::Associa
226
232
  def invertible_for?(record); end
227
233
  def primary_key(klass); end
228
234
  def replace(record); end
229
- def replace_keys(record); end
235
+ def replace_keys(record, force: T.unsafe(nil)); end
230
236
  def require_counter_update?; end
231
237
  def stale_state; end
232
238
  def update_counters(by); end
@@ -241,7 +247,7 @@ class ActiveRecord::Associations::BelongsToPolymorphicAssociation < ::ActiveReco
241
247
 
242
248
  def inverse_reflection_for(record); end
243
249
  def raise_on_type_mismatch!(record); end
244
- def replace_keys(record); end
250
+ def replace_keys(record, force: T.unsafe(nil)); end
245
251
  def stale_state; end
246
252
  end
247
253
 
@@ -253,13 +259,14 @@ class ActiveRecord::Associations::Builder::Association
253
259
  def build(model, name, scope, options, &block); end
254
260
  def create_reflection(model, name, scope, options, &block); end
255
261
  def extensions; end
256
- def extensions=(_); end
262
+ def extensions=(_arg0); end
257
263
 
258
264
  private
259
265
 
266
+ def add_after_commit_jobs_callback(model, dependent); end
260
267
  def add_destroy_callbacks(model, reflection); end
261
268
  def build_scope(scope); end
262
- def check_dependent_options(dependent); end
269
+ def check_dependent_options(dependent, model); end
263
270
  def define_accessors(model, reflection); end
264
271
  def define_callbacks(model, reflection); end
265
272
  def define_extensions(model, name); end
@@ -392,7 +399,6 @@ class ActiveRecord::Associations::CollectionAssociation < ::ActiveRecord::Associ
392
399
  def scope; end
393
400
  def size; end
394
401
  def target=(record); end
395
- def transaction(*args); end
396
402
  def writer(records); end
397
403
 
398
404
  private
@@ -411,172 +417,183 @@ class ActiveRecord::Associations::CollectionAssociation < ::ActiveRecord::Associ
411
417
  def replace_common_records_in_memory(new_target, original_target); end
412
418
  def replace_on_target(record, index, skip_callbacks); end
413
419
  def replace_records(new_target, original_target); end
420
+ def transaction(&block); end
414
421
  end
415
422
 
416
423
  class ActiveRecord::Associations::CollectionProxy < ::ActiveRecord::Relation
417
- def initialize(klass, association, **_); end
424
+ def initialize(klass, association, **_arg2); end
418
425
 
419
426
  def <<(*records); end
420
427
  def ==(other); end
421
- def _select!(*args, &block); end
422
- def annotate(*args, &block); end
423
- def annotate!(*args, &block); end
424
- def annotate_values(*args, &block); end
428
+ def _select!(*_arg0, &_arg1); end
429
+ def and(*_arg0, &_arg1); end
430
+ def and!(*_arg0, &_arg1); end
431
+ def annotate(*_arg0, &_arg1); end
432
+ def annotate!(*_arg0, &_arg1); end
433
+ def annotate_values(*_arg0, &_arg1); end
425
434
  def annotate_values=(arg); end
426
435
  def append(*records); end
427
- def arel(*args, &block); end
436
+ def arel(*_arg0, &_arg1); end
428
437
  def build(attributes = T.unsafe(nil), &block); end
429
438
  def calculate(operation, column_name); end
430
439
  def clear; end
431
440
  def concat(*records); end
432
- def construct_join_dependency(*args, &block); end
441
+ def construct_join_dependency(*_arg0, &_arg1); end
433
442
  def create(attributes = T.unsafe(nil), &block); end
434
443
  def create!(attributes = T.unsafe(nil), &block); end
435
- def create_with(*args, &block); end
436
- def create_with!(*args, &block); end
437
- def create_with_value(*args, &block); end
444
+ def create_with(*_arg0, &_arg1); end
445
+ def create_with!(*_arg0, &_arg1); end
446
+ def create_with_value(*_arg0, &_arg1); end
438
447
  def create_with_value=(arg); end
439
448
  def delete(*records); end
440
449
  def delete_all(dependent = T.unsafe(nil)); end
441
450
  def destroy(*records); end
442
451
  def destroy_all; end
443
- def distinct(*args, &block); end
444
- def distinct!(*args, &block); end
445
- def distinct_value(*args, &block); end
452
+ def distinct(*_arg0, &_arg1); end
453
+ def distinct!(*_arg0, &_arg1); end
454
+ def distinct_value(*_arg0, &_arg1); end
446
455
  def distinct_value=(arg); end
447
- def eager_load(*args, &block); end
448
- def eager_load!(*args, &block); end
449
- def eager_load_values(*args, &block); end
456
+ def eager_load(*_arg0, &_arg1); end
457
+ def eager_load!(*_arg0, &_arg1); end
458
+ def eager_load_values(*_arg0, &_arg1); end
450
459
  def eager_load_values=(arg); end
451
460
  def empty?; end
452
- def except(*args, &block); end
453
- def extending(*args, &block); end
454
- def extending!(*args, &block); end
455
- def extending_values(*args, &block); end
461
+ def except(*_arg0, &_arg1); end
462
+ def excluding(*_arg0, &_arg1); end
463
+ def excluding!(*_arg0, &_arg1); end
464
+ def extending(*_arg0, &_arg1); end
465
+ def extending!(*_arg0, &_arg1); end
466
+ def extending_values(*_arg0, &_arg1); end
456
467
  def extending_values=(arg); end
457
- def extensions(*args, &block); end
458
- def extract_associated(*args, &block); end
468
+ def extensions(*_arg0, &_arg1); end
469
+ def extract_associated(*_arg0, &_arg1); end
459
470
  def find(*args); end
460
- def from(*args, &block); end
461
- def from!(*args, &block); end
462
- def from_clause(*args, &block); end
471
+ def from(*_arg0, &_arg1); end
472
+ def from!(*_arg0, &_arg1); end
473
+ def from_clause(*_arg0, &_arg1); end
463
474
  def from_clause=(arg); end
464
- def group(*args, &block); end
465
- def group!(*args, &block); end
466
- def group_values(*args, &block); end
475
+ def group(*_arg0, &_arg1); end
476
+ def group!(*_arg0, &_arg1); end
477
+ def group_values(*_arg0, &_arg1); end
467
478
  def group_values=(arg); end
468
- def having(*args, &block); end
469
- def having!(*args, &block); end
470
- def having_clause(*args, &block); end
479
+ def having(*_arg0, &_arg1); end
480
+ def having!(*_arg0, &_arg1); end
481
+ def having_clause(*_arg0, &_arg1); end
471
482
  def having_clause=(arg); end
472
483
  def include?(record); end
473
- def includes(*args, &block); end
474
- def includes!(*args, &block); end
475
- def includes_values(*args, &block); end
484
+ def includes(*_arg0, &_arg1); end
485
+ def includes!(*_arg0, &_arg1); end
486
+ def includes_values(*_arg0, &_arg1); end
476
487
  def includes_values=(arg); end
477
- def insert(*args, &block); end
478
- def insert!(*args, &block); end
479
- def insert_all(*args, &block); end
480
- def insert_all!(*args, &block); end
481
- def joins(*args, &block); end
482
- def joins!(*args, &block); end
483
- def joins_values(*args, &block); end
488
+ def insert(*_arg0, &_arg1); end
489
+ def insert!(*_arg0, &_arg1); end
490
+ def insert_all(*_arg0, &_arg1); end
491
+ def insert_all!(*_arg0, &_arg1); end
492
+ def inspect; end
493
+ def invert_where(*_arg0, &_arg1); end
494
+ def invert_where!(*_arg0, &_arg1); end
495
+ def joins(*_arg0, &_arg1); end
496
+ def joins!(*_arg0, &_arg1); end
497
+ def joins_values(*_arg0, &_arg1); end
484
498
  def joins_values=(arg); end
485
499
  def last(limit = T.unsafe(nil)); end
486
- def left_joins(*args, &block); end
487
- def left_outer_joins(*args, &block); end
488
- def left_outer_joins!(*args, &block); end
489
- def left_outer_joins_values(*args, &block); end
500
+ def left_joins(*_arg0, &_arg1); end
501
+ def left_outer_joins(*_arg0, &_arg1); end
502
+ def left_outer_joins!(*_arg0, &_arg1); end
503
+ def left_outer_joins_values(*_arg0, &_arg1); end
490
504
  def left_outer_joins_values=(arg); end
491
- def limit(*args, &block); end
492
- def limit!(*args, &block); end
493
- def limit_value(*args, &block); end
505
+ def limit(*_arg0, &_arg1); end
506
+ def limit!(*_arg0, &_arg1); end
507
+ def limit_value(*_arg0, &_arg1); end
494
508
  def limit_value=(arg); end
495
509
  def load_target; end
510
+ def loaded; end
496
511
  def loaded?; end
497
- def lock(*args, &block); end
498
- def lock!(*args, &block); end
499
- def lock_value(*args, &block); end
512
+ def lock(*_arg0, &_arg1); end
513
+ def lock!(*_arg0, &_arg1); end
514
+ def lock_value(*_arg0, &_arg1); end
500
515
  def lock_value=(arg); end
501
- def merge(*args, &block); end
502
- def merge!(*args, &block); end
516
+ def merge(*_arg0, &_arg1); end
517
+ def merge!(*_arg0, &_arg1); end
503
518
  def new(attributes = T.unsafe(nil), &block); end
504
- def none(*args, &block); end
505
- def none!(*args, &block); end
506
- def offset(*args, &block); end
507
- def offset!(*args, &block); end
508
- def offset_value(*args, &block); end
519
+ def none(*_arg0, &_arg1); end
520
+ def none!(*_arg0, &_arg1); end
521
+ def offset(*_arg0, &_arg1); end
522
+ def offset!(*_arg0, &_arg1); end
523
+ def offset_value(*_arg0, &_arg1); end
509
524
  def offset_value=(arg); end
510
- def only(*args, &block); end
511
- def optimizer_hints(*args, &block); end
512
- def optimizer_hints!(*args, &block); end
513
- def optimizer_hints_values(*args, &block); end
525
+ def only(*_arg0, &_arg1); end
526
+ def optimizer_hints(*_arg0, &_arg1); end
527
+ def optimizer_hints!(*_arg0, &_arg1); end
528
+ def optimizer_hints_values(*_arg0, &_arg1); end
514
529
  def optimizer_hints_values=(arg); end
515
- def or(*args, &block); end
516
- def or!(*args, &block); end
517
- def order(*args, &block); end
518
- def order!(*args, &block); end
519
- def order_values(*args, &block); end
530
+ def or(*_arg0, &_arg1); end
531
+ def or!(*_arg0, &_arg1); end
532
+ def order(*_arg0, &_arg1); end
533
+ def order!(*_arg0, &_arg1); end
534
+ def order_values(*_arg0, &_arg1); end
520
535
  def order_values=(arg); end
521
536
  def pluck(*column_names); end
522
- def preload(*args, &block); end
523
- def preload!(*args, &block); end
524
- def preload_values(*args, &block); end
537
+ def preload(*_arg0, &_arg1); end
538
+ def preload!(*_arg0, &_arg1); end
539
+ def preload_values(*_arg0, &_arg1); end
525
540
  def preload_values=(arg); end
526
541
  def prepend(*args); end
527
542
  def proxy_association; end
528
543
  def push(*records); end
529
- def readonly(*args, &block); end
530
- def readonly!(*args, &block); end
531
- def readonly_value(*args, &block); end
544
+ def readonly(*_arg0, &_arg1); end
545
+ def readonly!(*_arg0, &_arg1); end
546
+ def readonly_value(*_arg0, &_arg1); end
532
547
  def readonly_value=(arg); end
533
548
  def records; end
534
- def references(*args, &block); end
535
- def references!(*args, &block); end
536
- def references_values(*args, &block); end
549
+ def references(*_arg0, &_arg1); end
550
+ def references!(*_arg0, &_arg1); end
551
+ def references_values(*_arg0, &_arg1); end
537
552
  def references_values=(arg); end
538
553
  def reload; end
539
- def reorder(*args, &block); end
540
- def reorder!(*args, &block); end
541
- def reordering_value(*args, &block); end
554
+ def reorder(*_arg0, &_arg1); end
555
+ def reorder!(*_arg0, &_arg1); end
556
+ def reordering_value(*_arg0, &_arg1); end
542
557
  def reordering_value=(arg); end
543
558
  def replace(other_array); end
544
- def reselect(*args, &block); end
545
- def reselect!(*args, &block); end
559
+ def reselect(*_arg0, &_arg1); end
560
+ def reselect!(*_arg0, &_arg1); end
546
561
  def reset; end
547
562
  def reset_scope; end
548
- def reverse_order(*args, &block); end
549
- def reverse_order!(*args, &block); end
550
- def reverse_order_value(*args, &block); end
563
+ def reverse_order(*_arg0, &_arg1); end
564
+ def reverse_order!(*_arg0, &_arg1); end
565
+ def reverse_order_value(*_arg0, &_arg1); end
551
566
  def reverse_order_value=(arg); end
552
- def rewhere(*args, &block); end
567
+ def rewhere(*_arg0, &_arg1); end
553
568
  def scope; end
554
- def scoping(*args, &block); end
555
- def select_values(*args, &block); end
569
+ def scoping(*_arg0, &_arg1); end
570
+ def select_values(*_arg0, &_arg1); end
556
571
  def select_values=(arg); end
557
572
  def size; end
558
- def skip_preloading!(*args, &block); end
559
- def skip_query_cache!(*args, &block); end
560
- def skip_query_cache_value(*args, &block); end
573
+ def skip_preloading!(*_arg0, &_arg1); end
574
+ def skip_query_cache!(*_arg0, &_arg1); end
575
+ def skip_query_cache_value(*_arg0, &_arg1); end
561
576
  def skip_query_cache_value=(arg); end
562
- def spawn(*args, &block); end
563
- def strict_loading(*args, &block); end
564
- def strict_loading!(*args, &block); end
565
- def strict_loading_value(*args, &block); end
577
+ def spawn(*_arg0, &_arg1); end
578
+ def strict_loading(*_arg0, &_arg1); end
579
+ def strict_loading!(*_arg0, &_arg1); end
580
+ def strict_loading_value(*_arg0, &_arg1); end
566
581
  def strict_loading_value=(arg); end
567
582
  def take(limit = T.unsafe(nil)); end
568
583
  def target; end
569
- def unscope(*args, &block); end
570
- def unscope!(*args, &block); end
571
- def unscope_values(*args, &block); end
584
+ def uniq!(*_arg0, &_arg1); end
585
+ def unscope(*_arg0, &_arg1); end
586
+ def unscope!(*_arg0, &_arg1); end
587
+ def unscope_values(*_arg0, &_arg1); end
572
588
  def unscope_values=(arg); end
573
- def upsert(*args, &block); end
574
- def upsert_all(*args, &block); end
575
- def values(*args, &block); end
576
- def where(*args, &block); end
577
- def where!(*args, &block); end
578
- def where_clause(*args, &block); end
589
+ def upsert(*_arg0, &_arg1); end
590
+ def upsert_all(*_arg0, &_arg1); end
591
+ def values(*_arg0, &_arg1); end
592
+ def where(*_arg0, &_arg1); end
593
+ def where!(*_arg0, &_arg1); end
594
+ def where_clause(*_arg0, &_arg1); end
579
595
  def where_clause=(arg); end
596
+ def without(*_arg0, &_arg1); end
580
597
 
581
598
  private
582
599
 
@@ -590,6 +607,10 @@ end
590
607
  module ActiveRecord::Associations::ForeignAssociation
591
608
  def foreign_key_present?; end
592
609
  def nullified_owner_attributes; end
610
+
611
+ private
612
+
613
+ def set_owner_attributes(record); end
593
614
  end
594
615
 
595
616
  class ActiveRecord::Associations::HasManyAssociation < ::ActiveRecord::Associations::CollectionAssociation
@@ -600,8 +621,8 @@ class ActiveRecord::Associations::HasManyAssociation < ::ActiveRecord::Associati
600
621
 
601
622
  private
602
623
 
603
- def _create_record(attributes, *_); end
604
- def concat_records(records, *_); end
624
+ def _create_record(attributes, *_arg1); end
625
+ def concat_records(records, *_arg1); end
605
626
  def count_records; end
606
627
  def delete_count(method, scope); end
607
628
  def delete_or_nullify_all_records(method); end
@@ -639,6 +660,7 @@ class ActiveRecord::Associations::HasManyThroughAssociation < ::ActiveRecord::As
639
660
  def save_through_record(record); end
640
661
  def target_reflection_has_associated_record?; end
641
662
  def through_records_for(record); end
663
+ def through_scope; end
642
664
  def through_scope_attributes; end
643
665
  def update_through_counter?(method); end
644
666
  end
@@ -674,8 +696,9 @@ class ActiveRecord::Associations::JoinDependency
674
696
 
675
697
  def apply_column_aliases(relation); end
676
698
  def base_klass; end
699
+ def each(&block); end
677
700
  def instantiate(result_set, strict_loading_value, &block); end
678
- def join_constraints(joins_to_add, alias_tracker); end
701
+ def join_constraints(joins_to_add, alias_tracker, references); end
679
702
  def reflections; end
680
703
 
681
704
  protected
@@ -690,13 +713,10 @@ class ActiveRecord::Associations::JoinDependency
690
713
  def build(associations, base_klass); end
691
714
  def construct(ar_parent, parent, row, seen, model_cache, strict_loading_value); end
692
715
  def construct_model(record, node, row, model_cache, id, strict_loading_value); end
693
- def construct_tables!(join_root); end
694
- def explicit_selections(root_column_aliases, result_set); end
695
716
  def find_reflection(klass, name); end
717
+ def join_root_alias; end
696
718
  def make_constraints(parent, child, join_type); end
697
719
  def make_join_constraints(join_root, join_type); end
698
- def table_alias_for(reflection, parent, join); end
699
- def table_aliases_for(parent, node); end
700
720
  def walk(left, right, join_type); end
701
721
 
702
722
  class << self
@@ -720,10 +740,10 @@ class ActiveRecord::Associations::JoinDependency::Aliases::Column < ::Struct
720
740
  def name=(_); end
721
741
 
722
742
  class << self
723
- def [](*_); end
743
+ def [](*_arg0); end
724
744
  def inspect; end
725
745
  def members; end
726
- def new(*_); end
746
+ def new(*_arg0); end
727
747
  end
728
748
  end
729
749
 
@@ -735,10 +755,10 @@ class ActiveRecord::Associations::JoinDependency::Aliases::Table < ::Struct
735
755
  def node=(_); end
736
756
 
737
757
  class << self
738
- def [](*_); end
758
+ def [](*_arg0); end
739
759
  def inspect; end
740
760
  def members; end
741
- def new(*_); end
761
+ def new(*_arg0); end
742
762
  end
743
763
  end
744
764
 
@@ -751,9 +771,8 @@ class ActiveRecord::Associations::JoinDependency::JoinAssociation < ::ActiveReco
751
771
  def reflection; end
752
772
  def strict_loading?; end
753
773
  def table; end
754
- def table=(_); end
774
+ def table=(_arg0); end
755
775
  def tables; end
756
- def tables=(tables); end
757
776
 
758
777
  private
759
778
 
@@ -770,66 +789,106 @@ end
770
789
  class ActiveRecord::Associations::Preloader
771
790
  extend(::ActiveSupport::Autoload)
772
791
 
773
- def preload(records, associations, preload_scope = T.unsafe(nil)); end
774
-
775
- private
776
-
777
- def grouped_records(association, records, polymorphic_parent); end
778
- def preloader_for(reflection, owners); end
779
- def preloaders_for_hash(association, records, scope, polymorphic_parent); end
780
- def preloaders_for_one(association, records, scope, polymorphic_parent); end
781
- def preloaders_for_reflection(reflection, records, scope); end
782
- def preloaders_on(association, records, scope, polymorphic_parent = T.unsafe(nil)); end
783
- end
784
-
785
- class ActiveRecord::Associations::Preloader::AlreadyLoaded
786
- def initialize(klass, owners, reflection, preload_scope); end
787
-
788
- def preloaded_records; end
789
- def records_by_owner; end
790
- def run; end
791
-
792
- private
792
+ def initialize(associate_by_default: T.unsafe(nil), **kwargs); end
793
793
 
794
- def owners; end
795
- def reflection; end
794
+ def associate_by_default; end
795
+ def associations; end
796
+ def branches; end
797
+ def call; end
798
+ def empty?; end
799
+ def loaders; end
800
+ def preload(records, associations, preload_scope = T.unsafe(nil)); end
801
+ def records; end
802
+ def scope; end
796
803
  end
797
804
 
798
805
  class ActiveRecord::Associations::Preloader::Association
799
- def initialize(klass, owners, reflection, preload_scope); end
806
+ def initialize(klass, owners, reflection, preload_scope, associate_by_default = T.unsafe(nil)); end
800
807
 
808
+ def already_loaded?; end
809
+ def association_key_name; end
810
+ def ensure_loaded; end
811
+ def load_records(raw_records = T.unsafe(nil)); end
812
+ def loader_query; end
813
+ def owner_keys; end
801
814
  def preloaded_records; end
802
815
  def records_by_owner; end
803
816
  def run; end
817
+ def run?; end
818
+ def runnable_loaders; end
819
+ def scope; end
820
+ def set_inverse(record); end
804
821
 
805
822
  private
806
823
 
807
824
  def associate_records_to_owner(owner, records); end
808
- def association_key_name; end
809
825
  def association_key_type; end
810
826
  def build_scope; end
811
827
  def convert_key(key); end
828
+ def fetch_from_preloaded_records; end
812
829
  def key_conversion_required?; end
813
830
  def klass; end
814
- def load_records; end
815
831
  def model; end
816
832
  def owner_key_name; end
817
833
  def owner_key_type; end
818
- def owner_keys; end
819
834
  def owners; end
820
835
  def owners_by_key; end
821
836
  def preload_scope; end
822
- def records_for(ids); end
823
837
  def reflection; end
824
838
  def reflection_scope; end
839
+ end
840
+
841
+ class ActiveRecord::Associations::Preloader::Association::LoaderQuery
842
+ def initialize(scope, association_key_name); end
843
+
844
+ def association_key_name; end
845
+ def eql?(other); end
846
+ def hash; end
847
+ def load_records_in_batch(loaders); end
848
+ def records_for(loaders); end
825
849
  def scope; end
826
850
  end
827
851
 
828
- class ActiveRecord::Associations::Preloader::ThroughAssociation < ::ActiveRecord::Associations::Preloader::Association
829
- def initialize(*_); end
852
+ class ActiveRecord::Associations::Preloader::Batch
853
+ def initialize(preloaders); end
854
+
855
+ def call; end
856
+
857
+ private
858
+
859
+ def group_and_load_similar(loaders); end
860
+ def loaders; end
861
+ end
862
+
863
+ class ActiveRecord::Associations::Preloader::Branch
864
+ def initialize(association:, children:, parent:, associate_by_default:, scope:); end
865
+
866
+ def associate_by_default; end
867
+ def association; end
868
+ def children; end
869
+ def done?; end
870
+ def grouped_records; end
871
+ def loaders; end
872
+ def parent; end
873
+ def polymorphic?; end
874
+ def preloaded_records; end
875
+ def preloaded_records=(_arg0); end
876
+ def preloaders_for_reflection(reflection, reflection_records); end
877
+ def root?; end
878
+ def runnable_loaders; end
879
+ def scope; end
880
+ def source_records; end
830
881
 
882
+ private
883
+
884
+ def build_children(children); end
885
+ def preloader_for(reflection); end
886
+ end
887
+
888
+ class ActiveRecord::Associations::Preloader::ThroughAssociation < ::ActiveRecord::Associations::Preloader::Association
831
889
  def preloaded_records; end
832
890
  def records_by_owner; end
891
+ def runnable_loaders; end
833
892
 
834
893
  private
835
894
 
@@ -842,8 +901,6 @@ class ActiveRecord::Associations::Preloader::ThroughAssociation < ::ActiveRecord
842
901
  def through_scope; end
843
902
  end
844
903
 
845
- ActiveRecord::Associations::Preloader::ThroughAssociation::PRELOADER = T.let(T.unsafe(nil), ActiveRecord::Associations::Preloader)
846
-
847
904
  class ActiveRecord::Associations::SingularAssociation < ::ActiveRecord::Associations::Association
848
905
  def build(attributes = T.unsafe(nil), &block); end
849
906
  def force_reload_reader; end
@@ -860,7 +917,7 @@ class ActiveRecord::Associations::SingularAssociation < ::ActiveRecord::Associat
860
917
  end
861
918
 
862
919
  module ActiveRecord::Associations::ThroughAssociation
863
- def source_reflection(*args, &block); end
920
+ def source_reflection(*_arg0, &_arg1); end
864
921
 
865
922
  private
866
923
 
@@ -875,6 +932,36 @@ module ActiveRecord::Associations::ThroughAssociation
875
932
  def through_reflection; end
876
933
  end
877
934
 
935
+ class ActiveRecord::AsynchronousQueriesTracker
936
+ def initialize; end
937
+
938
+ def current_session; end
939
+ def finalize_session; end
940
+ def start_session; end
941
+
942
+ class << self
943
+ def complete(asynchronous_queries_tracker); end
944
+ def install_executor_hooks(executor = T.unsafe(nil)); end
945
+ def run; end
946
+ end
947
+ end
948
+
949
+ module ActiveRecord::AsynchronousQueriesTracker::NullSession
950
+ class << self
951
+ def active?; end
952
+ end
953
+ end
954
+
955
+ class ActiveRecord::AsynchronousQueriesTracker::Session
956
+ def initialize; end
957
+
958
+ def active?; end
959
+ def finalize; end
960
+ end
961
+
962
+ class ActiveRecord::AsynchronousQueryInsideTransactionError < ::ActiveRecord::ActiveRecordError
963
+ end
964
+
878
965
  module ActiveRecord::AttributeAssignment
879
966
  include(::ActiveModel::ForbiddenAttributesProtection)
880
967
  include(::ActiveModel::AttributeAssignment)
@@ -898,34 +985,6 @@ class ActiveRecord::AttributeAssignmentError < ::ActiveRecord::ActiveRecordError
898
985
  def exception; end
899
986
  end
900
987
 
901
- module ActiveRecord::AttributeDecorators
902
- extend(::ActiveSupport::Concern)
903
-
904
- mixes_in_class_methods(::ActiveRecord::AttributeDecorators::ClassMethods)
905
- end
906
-
907
- module ActiveRecord::AttributeDecorators::ClassMethods
908
- def decorate_attribute_type(column_name, decorator_name, &block); end
909
- def decorate_matching_attribute_types(matcher, decorator_name, &block); end
910
-
911
- private
912
-
913
- def load_schema!; end
914
- end
915
-
916
- class ActiveRecord::AttributeDecorators::TypeDecorator
917
- def initialize(decorations = T.unsafe(nil)); end
918
-
919
- def apply(name, type); end
920
- def clear(*args, &block); end
921
- def merge(*args); end
922
-
923
- private
924
-
925
- def decorators_for(name, type); end
926
- def matching(name, type); end
927
- end
928
-
929
988
  module ActiveRecord::AttributeMethods
930
989
  extend(::ActiveSupport::Concern)
931
990
  extend(::ActiveSupport::Autoload)
@@ -945,10 +1004,11 @@ module ActiveRecord::AttributeMethods
945
1004
 
946
1005
  def [](attr_name); end
947
1006
  def []=(attr_name, value); end
1007
+ def _has_attribute?(attr_name); end
948
1008
  def accessed_fields; end
949
1009
  def attribute_for_inspect(attr_name); end
950
1010
  def attribute_names; end
951
- def attribute_present?(attribute); end
1011
+ def attribute_present?(attr_name); end
952
1012
  def attributes; end
953
1013
  def has_attribute?(attr_name); end
954
1014
  def respond_to?(name, include_private = T.unsafe(nil)); end
@@ -959,8 +1019,12 @@ module ActiveRecord::AttributeMethods
959
1019
  def attributes_for_create(attribute_names); end
960
1020
  def attributes_for_update(attribute_names); end
961
1021
  def attributes_with_values(attribute_names); end
962
- def format_for_inspect(value); end
1022
+ def format_for_inspect(name, value); end
963
1023
  def pk_attribute?(name); end
1024
+
1025
+ class << self
1026
+ def dangerous_attribute_methods; end
1027
+ end
964
1028
  end
965
1029
 
966
1030
  module ActiveRecord::AttributeMethods::BeforeTypeCast
@@ -971,14 +1035,15 @@ module ActiveRecord::AttributeMethods::BeforeTypeCast
971
1035
 
972
1036
  private
973
1037
 
974
- def attribute_before_type_cast(attribute_name); end
975
- def attribute_came_from_user?(attribute_name); end
1038
+ def attribute_before_type_cast(attr_name); end
1039
+ def attribute_came_from_user?(attr_name); end
1040
+ def attribute_for_database(attr_name); end
976
1041
  end
977
1042
 
978
1043
  module ActiveRecord::AttributeMethods::ClassMethods
1044
+ def _has_attribute?(attr_name); end
979
1045
  def attribute_method?(attribute); end
980
1046
  def attribute_names; end
981
- def column_for_attribute(name); end
982
1047
  def dangerous_attribute_method?(name); end
983
1048
  def dangerous_class_method?(method_name); end
984
1049
  def define_attribute_methods; end
@@ -1003,7 +1068,7 @@ module ActiveRecord::AttributeMethods::Dirty
1003
1068
  def changed_attribute_names_to_save; end
1004
1069
  def changes_to_save; end
1005
1070
  def has_changes_to_save?; end
1006
- def reload(*_); end
1071
+ def reload(*_arg0); end
1007
1072
  def saved_change_to_attribute(attr_name); end
1008
1073
  def saved_change_to_attribute?(attr_name, **options); end
1009
1074
  def saved_changes; end
@@ -1016,9 +1081,6 @@ module ActiveRecord::AttributeMethods::Dirty
1016
1081
  def _touch_row(attribute_names, time); end
1017
1082
  def _update_record(attribute_names = T.unsafe(nil)); end
1018
1083
  def attribute_names_for_partial_writes; end
1019
- def mutations_before_last_save; end
1020
- def mutations_from_database; end
1021
- def write_attribute_without_type_cast(attr_name, value); end
1022
1084
  end
1023
1085
 
1024
1086
  class ActiveRecord::AttributeMethods::GeneratedAttributeMethods < ::Module
@@ -1040,6 +1102,7 @@ module ActiveRecord::AttributeMethods::PrimaryKey
1040
1102
  def id=(value); end
1041
1103
  def id?; end
1042
1104
  def id_before_type_cast; end
1105
+ def id_for_database; end
1043
1106
  def id_in_database; end
1044
1107
  def id_was; end
1045
1108
  def to_key; end
@@ -1072,7 +1135,7 @@ module ActiveRecord::AttributeMethods::Query
1072
1135
 
1073
1136
  private
1074
1137
 
1075
- def attribute?(attribute_name); end
1138
+ def attribute?(attr_name); end
1076
1139
  end
1077
1140
 
1078
1141
  ActiveRecord::AttributeMethods::RESTRICTED_CLASS_METHODS = T.let(T.unsafe(nil), Array)
@@ -1104,7 +1167,7 @@ module ActiveRecord::AttributeMethods::Serialization
1104
1167
  end
1105
1168
 
1106
1169
  module ActiveRecord::AttributeMethods::Serialization::ClassMethods
1107
- def serialize(attr_name, class_name_or_coder = T.unsafe(nil)); end
1170
+ def serialize(attr_name, class_name_or_coder = T.unsafe(nil), **options); end
1108
1171
 
1109
1172
  private
1110
1173
 
@@ -1122,11 +1185,11 @@ module ActiveRecord::AttributeMethods::TimeZoneConversion
1122
1185
  end
1123
1186
 
1124
1187
  module ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods
1188
+ def define_attribute(name, cast_type, **_arg2); end
1125
1189
 
1126
1190
  private
1127
1191
 
1128
1192
  def create_time_zone_conversion_attribute?(name, cast_type); end
1129
- def inherited(subclass); end
1130
1193
  end
1131
1194
 
1132
1195
  class ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
@@ -1138,6 +1201,10 @@ class ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
1138
1201
  def convert_time_to_time_zone(value); end
1139
1202
  def map_avoiding_infinite_recursion(value); end
1140
1203
  def set_time_zone_without_conversion(value); end
1204
+
1205
+ class << self
1206
+ def new(subtype); end
1207
+ end
1141
1208
  end
1142
1209
 
1143
1210
  module ActiveRecord::AttributeMethods::Write
@@ -1150,8 +1217,7 @@ module ActiveRecord::AttributeMethods::Write
1150
1217
 
1151
1218
  private
1152
1219
 
1153
- def attribute=(attribute_name, value); end
1154
- def write_attribute_without_type_cast(attr_name, value); end
1220
+ def attribute=(attr_name, value); end
1155
1221
  end
1156
1222
 
1157
1223
  module ActiveRecord::AttributeMethods::Write::ClassMethods
@@ -1168,7 +1234,7 @@ module ActiveRecord::Attributes
1168
1234
  end
1169
1235
 
1170
1236
  module ActiveRecord::Attributes::ClassMethods
1171
- def attribute(name, cast_type = T.unsafe(nil), **options); end
1237
+ def attribute(name, cast_type = T.unsafe(nil), default: T.unsafe(nil), **options); end
1172
1238
  def define_attribute(name, cast_type, default: T.unsafe(nil), user_provided_default: T.unsafe(nil)); end
1173
1239
  def load_schema!; end
1174
1240
 
@@ -1192,11 +1258,10 @@ module ActiveRecord::AutosaveAssociation
1192
1258
  private
1193
1259
 
1194
1260
  def _ensure_no_duplicate_errors; end
1195
- def after_save_collection_association; end
1261
+ def around_save_collection_association; end
1196
1262
  def associated_records_to_validate_or_save(association, new_record, autosave); end
1197
1263
  def association_foreign_key_changed?(reflection, record, key); end
1198
1264
  def association_valid?(reflection, record, index = T.unsafe(nil)); end
1199
- def before_save_collection_association; end
1200
1265
  def custom_validation_context?; end
1201
1266
  def nested_records_changed_for_autosave?; end
1202
1267
  def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute); end
@@ -1245,7 +1310,6 @@ class ActiveRecord::Base
1245
1310
  include(::ActiveRecord::Validations)
1246
1311
  include(::ActiveRecord::CounterCache)
1247
1312
  include(::ActiveRecord::Attributes)
1248
- include(::ActiveRecord::AttributeDecorators)
1249
1313
  include(::ActiveRecord::Locking::Optimistic)
1250
1314
  include(::ActiveRecord::Locking::Pessimistic)
1251
1315
  include(::ActiveModel::AttributeMethods)
@@ -1275,6 +1339,7 @@ class ActiveRecord::Base
1275
1339
  include(::ActiveRecord::Serialization)
1276
1340
  include(::ActiveRecord::Store)
1277
1341
  include(::ActiveRecord::SecureToken)
1342
+ include(::ActiveRecord::SignedId)
1278
1343
  include(::ActiveRecord::Suppressor)
1279
1344
  extend(::ActiveModel::Naming)
1280
1345
  extend(::ActiveSupport::Benchmarkable)
@@ -1285,6 +1350,7 @@ class ActiveRecord::Base
1285
1350
  extend(::ActiveModel::Translation)
1286
1351
  extend(::ActiveRecord::Translation)
1287
1352
  extend(::ActiveRecord::DynamicMatchers)
1353
+ extend(::ActiveRecord::DelegatedType)
1288
1354
  extend(::ActiveRecord::Explain)
1289
1355
  extend(::ActiveRecord::Enum)
1290
1356
  extend(::ActiveRecord::Delegation::DelegateCache)
@@ -1307,7 +1373,6 @@ class ActiveRecord::Base
1307
1373
  extend(::ActiveRecord::Validations::ClassMethods)
1308
1374
  extend(::ActiveRecord::CounterCache::ClassMethods)
1309
1375
  extend(::ActiveRecord::Attributes::ClassMethods)
1310
- extend(::ActiveRecord::AttributeDecorators::ClassMethods)
1311
1376
  extend(::ActiveRecord::Locking::Optimistic::ClassMethods)
1312
1377
  extend(::ActiveModel::AttributeMethods::ClassMethods)
1313
1378
  extend(::ActiveRecord::AttributeMethods::ClassMethods)
@@ -1328,6 +1393,7 @@ class ActiveRecord::Base
1328
1393
  extend(::ActiveRecord::Reflection::ClassMethods)
1329
1394
  extend(::ActiveRecord::Store::ClassMethods)
1330
1395
  extend(::ActiveRecord::SecureToken::ClassMethods)
1396
+ extend(::ActiveRecord::SignedId::ClassMethods)
1331
1397
  extend(::ActiveRecord::Suppressor::ClassMethods)
1332
1398
 
1333
1399
  def __callbacks; end
@@ -1362,7 +1428,6 @@ class ActiveRecord::Base
1362
1428
  def _validators?; end
1363
1429
  def aggregate_reflections; end
1364
1430
  def aggregate_reflections?; end
1365
- def allow_unsafe_raw_sql; end
1366
1431
  def attribute_aliases; end
1367
1432
  def attribute_aliases?; end
1368
1433
  def attribute_method_matchers; end
@@ -1373,26 +1438,30 @@ class ActiveRecord::Base
1373
1438
  def cache_versioning?; end
1374
1439
  def collection_cache_versioning; end
1375
1440
  def collection_cache_versioning?; end
1376
- def column_for_attribute(*args, &block); end
1441
+ def column_for_attribute(*_arg0, &_arg1); end
1377
1442
  def default_connection_handler; end
1378
1443
  def default_connection_handler?; end
1379
- def default_pool_key; end
1380
- def default_pool_key?; end
1444
+ def default_role; end
1445
+ def default_role?; end
1381
1446
  def default_scope_override; end
1382
1447
  def default_scopes; end
1448
+ def default_shard; end
1449
+ def default_shard?; end
1383
1450
  def default_timezone; end
1384
1451
  def defined_enums; end
1385
1452
  def defined_enums?; end
1453
+ def destroy_association_async_job; end
1386
1454
  def dump_schema_after_migration; end
1387
1455
  def dump_schemas; end
1388
1456
  def error_on_ignored_order; end
1389
1457
  def include_root_in_json; end
1390
1458
  def include_root_in_json?; end
1391
1459
  def index_nested_attribute_errors; end
1460
+ def legacy_connection_handling; end
1392
1461
  def lock_optimistically; end
1393
1462
  def lock_optimistically?; end
1394
1463
  def logger; end
1395
- def model_name(*args, &block); end
1464
+ def model_name(*_arg0, &_arg1); end
1396
1465
  def nested_attributes_options; end
1397
1466
  def nested_attributes_options?; end
1398
1467
  def partial_writes; end
@@ -1401,13 +1470,20 @@ class ActiveRecord::Base
1401
1470
  def pluralize_table_names?; end
1402
1471
  def primary_key_prefix_type; end
1403
1472
  def record_timestamps; end
1404
- def record_timestamps=(_); end
1473
+ def record_timestamps=(_arg0); end
1405
1474
  def record_timestamps?; end
1406
1475
  def schema_format; end
1476
+ def signed_id_verifier_secret; end
1407
1477
  def skip_time_zone_conversion_for_attributes; end
1408
1478
  def skip_time_zone_conversion_for_attributes?; end
1479
+ def store_full_class_name; end
1480
+ def store_full_class_name?; end
1409
1481
  def store_full_sti_class; end
1410
1482
  def store_full_sti_class?; end
1483
+ def strict_loading_mode; end
1484
+ def strict_loading_mode=(_arg0); end
1485
+ def strict_loading_mode?; end
1486
+ def suppress_multiple_database_warning; end
1411
1487
  def table_name_prefix; end
1412
1488
  def table_name_prefix?; end
1413
1489
  def table_name_suffix; end
@@ -1416,14 +1492,14 @@ class ActiveRecord::Base
1416
1492
  def time_zone_aware_types; end
1417
1493
  def time_zone_aware_types?; end
1418
1494
  def timestamped_migrations; end
1419
- def type_for_attribute(*args, &block); end
1495
+ def type_for_attribute(*_arg0, &_arg1); end
1420
1496
  def validation_context; end
1421
1497
  def verbose_query_logs; end
1422
1498
  def warn_on_records_fetched_greater_than; end
1423
1499
 
1424
1500
  private
1425
1501
 
1426
- def validation_context=(_); end
1502
+ def validation_context=(_arg0); end
1427
1503
 
1428
1504
  class << self
1429
1505
  def __callbacks; end
@@ -1462,6 +1538,8 @@ class ActiveRecord::Base
1462
1538
  def _validators; end
1463
1539
  def _validators=(value); end
1464
1540
  def _validators?; end
1541
+ def action_on_strict_loading_violation; end
1542
+ def action_on_strict_loading_violation=(val); end
1465
1543
  def after_create(*args, **options, &block); end
1466
1544
  def after_destroy(*args, **options, &block); end
1467
1545
  def after_find(*args, **options, &block); end
@@ -1473,20 +1551,24 @@ class ActiveRecord::Base
1473
1551
  def aggregate_reflections=(value); end
1474
1552
  def aggregate_reflections?; end
1475
1553
  def allow_unsafe_raw_sql; end
1476
- def allow_unsafe_raw_sql=(val); end
1554
+ def allow_unsafe_raw_sql=(value); end
1555
+ def application_record_class; end
1556
+ def application_record_class=(val); end
1557
+ def application_record_class?; end
1477
1558
  def around_create(*args, **options, &block); end
1478
1559
  def around_destroy(*args, **options, &block); end
1479
1560
  def around_save(*args, **options, &block); end
1480
1561
  def around_update(*args, **options, &block); end
1562
+ def async_query_executor; end
1563
+ def async_query_executor=(val); end
1564
+ def asynchronous_queries_session; end
1565
+ def asynchronous_queries_tracker; end
1481
1566
  def attribute_aliases; end
1482
1567
  def attribute_aliases=(value); end
1483
1568
  def attribute_aliases?; end
1484
1569
  def attribute_method_matchers; end
1485
1570
  def attribute_method_matchers=(value); end
1486
1571
  def attribute_method_matchers?; end
1487
- def attribute_type_decorations; end
1488
- def attribute_type_decorations=(value); end
1489
- def attribute_type_decorations?; end
1490
1572
  def attributes_to_define_after_schema_loads; end
1491
1573
  def attributes_to_define_after_schema_loads=(value); end
1492
1574
  def attributes_to_define_after_schema_loads?; end
@@ -1508,35 +1590,52 @@ class ActiveRecord::Base
1508
1590
  def collection_cache_versioning?; end
1509
1591
  def configurations; end
1510
1592
  def configurations=(config); end
1593
+ def connected_to_stack; end
1594
+ def connection_class; end
1595
+ def connection_class=(b); end
1596
+ def connection_class?; end
1597
+ def connection_classes; end
1511
1598
  def connection_handler; end
1512
1599
  def connection_handler=(handler); end
1513
1600
  def connection_handlers; end
1514
- def connection_handlers=(val); end
1515
- def current_pool_key; end
1516
- def current_pool_key=(pool_key); end
1601
+ def connection_handlers=(handlers); end
1602
+ def current_preventing_writes; end
1603
+ def current_role; end
1604
+ def current_shard; end
1517
1605
  def default_connection_handler; end
1518
1606
  def default_connection_handler=(value); end
1519
1607
  def default_connection_handler?; end
1520
- def default_pool_key; end
1521
- def default_pool_key=(value); end
1522
- def default_pool_key?; end
1608
+ def default_role; end
1609
+ def default_role=(value); end
1610
+ def default_role?; end
1523
1611
  def default_scope_override; end
1524
1612
  def default_scope_override=(value); end
1525
1613
  def default_scopes; end
1526
1614
  def default_scopes=(value); end
1615
+ def default_shard; end
1616
+ def default_shard=(value); end
1617
+ def default_shard?; end
1527
1618
  def default_timezone; end
1528
1619
  def default_timezone=(val); end
1529
1620
  def defined_enums; end
1530
1621
  def defined_enums=(value); end
1531
1622
  def defined_enums?; end
1623
+ def destroy_association_async_job; end
1624
+ def destroy_association_async_job=(value); end
1532
1625
  def dump_schema_after_migration; end
1533
1626
  def dump_schema_after_migration=(val); end
1534
1627
  def dump_schemas; end
1535
1628
  def dump_schemas=(val); end
1536
1629
  def error_on_ignored_order; end
1537
1630
  def error_on_ignored_order=(val); end
1631
+ def global_executor_concurrency; end
1632
+ def global_executor_concurrency=(global_executor_concurrency); end
1633
+ def global_thread_pool_async_query_executor; end
1538
1634
  def has_many_inversing; end
1539
1635
  def has_many_inversing=(val); end
1636
+ def immutable_strings_by_default; end
1637
+ def immutable_strings_by_default=(value); end
1638
+ def immutable_strings_by_default?; end
1540
1639
  def implicit_order_column; end
1541
1640
  def implicit_order_column=(value); end
1542
1641
  def implicit_order_column?; end
@@ -1548,8 +1647,10 @@ class ActiveRecord::Base
1548
1647
  def internal_metadata_table_name; end
1549
1648
  def internal_metadata_table_name=(value); end
1550
1649
  def internal_metadata_table_name?; end
1650
+ def legacy_connection_handling; end
1651
+ def legacy_connection_handling=(val); end
1551
1652
  def local_stored_attributes; end
1552
- def local_stored_attributes=(_); end
1653
+ def local_stored_attributes=(_arg0); end
1553
1654
  def lock_optimistically; end
1554
1655
  def lock_optimistically=(value); end
1555
1656
  def lock_optimistically?; end
@@ -1568,6 +1669,8 @@ class ActiveRecord::Base
1568
1669
  def pluralize_table_names?; end
1569
1670
  def primary_key_prefix_type; end
1570
1671
  def primary_key_prefix_type=(val); end
1672
+ def queues; end
1673
+ def queues=(val); end
1571
1674
  def reading_role; end
1572
1675
  def reading_role=(val); end
1573
1676
  def record_timestamps; end
@@ -1578,12 +1681,26 @@ class ActiveRecord::Base
1578
1681
  def schema_migrations_table_name; end
1579
1682
  def schema_migrations_table_name=(value); end
1580
1683
  def schema_migrations_table_name?; end
1684
+ def signed_id_verifier_secret; end
1685
+ def signed_id_verifier_secret=(val); end
1581
1686
  def skip_time_zone_conversion_for_attributes; end
1582
1687
  def skip_time_zone_conversion_for_attributes=(value); end
1583
1688
  def skip_time_zone_conversion_for_attributes?; end
1689
+ def store_full_class_name; end
1690
+ def store_full_class_name=(value); end
1691
+ def store_full_class_name?; end
1584
1692
  def store_full_sti_class; end
1585
1693
  def store_full_sti_class=(value); end
1586
1694
  def store_full_sti_class?; end
1695
+ def strict_loading_by_default; end
1696
+ def strict_loading_by_default=(value); end
1697
+ def strict_loading_by_default?; end
1698
+ def strict_loading_mode; end
1699
+ def strict_loading_mode=(value); end
1700
+ def strict_loading_mode?; end
1701
+ def strict_loading_violation!(owner:, reflection:); end
1702
+ def suppress_multiple_database_warning; end
1703
+ def suppress_multiple_database_warning=(val); end
1587
1704
  def table_name_prefix; end
1588
1705
  def table_name_prefix=(value); end
1589
1706
  def table_name_prefix?; end
@@ -1625,11 +1742,11 @@ class ActiveRecord::Batches::BatchEnumerator
1625
1742
 
1626
1743
  def initialize(relation:, of: T.unsafe(nil), start: T.unsafe(nil), finish: T.unsafe(nil)); end
1627
1744
 
1628
- def delete_all(*args, &block); end
1629
- def destroy_all(*args, &block); end
1745
+ def delete_all; end
1746
+ def destroy_all; end
1630
1747
  def each; end
1631
1748
  def each_record; end
1632
- def update_all(*args, &block); end
1749
+ def update_all(updates); end
1633
1750
  end
1634
1751
 
1635
1752
  ActiveRecord::Batches::ORDER_IGNORE_MESSAGE = T.let(T.unsafe(nil), String)
@@ -1655,10 +1772,12 @@ module ActiveRecord::Calculations
1655
1772
  def execute_grouped_calculation(operation, column_name, distinct); end
1656
1773
  def execute_simple_calculation(operation, column_name, distinct); end
1657
1774
  def has_include?(column_name); end
1658
- def operation_over_aggregate_column(column_name, operation, distinct); end
1775
+ def lookup_cast_type_from_join_dependencies(name, join_dependencies = T.unsafe(nil)); end
1776
+ def operation_over_aggregate_column(column, operation, distinct); end
1659
1777
  def perform_calculation(operation, column_name); end
1660
1778
  def select_for_count; end
1661
- def type_cast_calculated_value(value, operation); end
1779
+ def type_cast_calculated_value(value, operation, type); end
1780
+ def type_cast_pluck_values(result, columns); end
1662
1781
  def type_for(field, &block); end
1663
1782
  end
1664
1783
 
@@ -1672,13 +1791,13 @@ module ActiveRecord::Callbacks
1672
1791
 
1673
1792
  def destroy; end
1674
1793
  def increment!(attribute, by = T.unsafe(nil), touch: T.unsafe(nil)); end
1675
- def touch(*_, **_); end
1794
+ def touch(*_arg0, **_arg1); end
1676
1795
 
1677
1796
  private
1678
1797
 
1679
1798
  def _create_record; end
1680
1799
  def _update_record; end
1681
- def create_or_update(**_); end
1800
+ def create_or_update(**_arg0); end
1682
1801
  end
1683
1802
 
1684
1803
  ActiveRecord::Callbacks::CALLBACKS = T.let(T.unsafe(nil), Array)
@@ -1704,7 +1823,7 @@ class ActiveRecord::Coders::YAMLColumn
1704
1823
  def dump(obj); end
1705
1824
  def load(yaml); end
1706
1825
  def object_class; end
1707
- def object_class=(_); end
1826
+ def object_class=(_arg0); end
1708
1827
 
1709
1828
  private
1710
1829
 
@@ -1741,29 +1860,33 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
1741
1860
  def active?; end
1742
1861
  def adapter_name; end
1743
1862
  def advisory_locks_enabled?; end
1863
+ def async_enabled?; end
1744
1864
  def build_insert_sql(insert); end
1745
1865
  def case_insensitive_comparison(attribute, value); end
1746
1866
  def case_sensitive_comparison(attribute, value); end
1867
+ def check_if_write_query(sql); end
1747
1868
  def check_version; end
1748
1869
  def clear_cache!; end
1749
1870
  def close; end
1871
+ def connection_klass; end
1872
+ def create(*_arg0); end
1750
1873
  def database_version; end
1751
1874
  def default_index_type?(index); end
1752
- def default_uniqueness_comparison(attribute, value, klass); end
1753
- def delete(*_); end
1875
+ def default_uniqueness_comparison(attribute, value); end
1876
+ def delete(*_arg0); end
1754
1877
  def disable_extension(name); end
1755
1878
  def disable_referential_integrity; end
1756
1879
  def discard!; end
1757
1880
  def disconnect!; end
1758
1881
  def enable_extension(name); end
1759
- def exec_insert_all(*_); end
1882
+ def exec_insert_all(*_arg0); end
1760
1883
  def expire; end
1761
1884
  def extensions; end
1762
1885
  def get_advisory_lock(lock_id); end
1763
1886
  def get_database_version; end
1764
1887
  def in_use?; end
1765
1888
  def index_algorithms; end
1766
- def insert(*_); end
1889
+ def insert(*_arg0); end
1767
1890
  def lease; end
1768
1891
  def lock; end
1769
1892
  def logger; end
@@ -1771,9 +1894,10 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
1771
1894
  def migrations_paths; end
1772
1895
  def owner; end
1773
1896
  def pool; end
1774
- def pool=(_); end
1897
+ def pool=(_arg0); end
1775
1898
  def prefetch_primary_key?(table_name = T.unsafe(nil)); end
1776
1899
  def prepared_statements; end
1900
+ def prepared_statements?; end
1777
1901
  def prepared_statements_disabled_cache; end
1778
1902
  def preventing_writes?; end
1779
1903
  def raw_connection; end
@@ -1782,8 +1906,8 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
1782
1906
  def replica?; end
1783
1907
  def requires_reloading?; end
1784
1908
  def reset!; end
1785
- def rollback_db_transaction(*_); end
1786
- def rollback_to_savepoint(*_); end
1909
+ def rollback_db_transaction(*_arg0); end
1910
+ def rollback_to_savepoint(*_arg0); end
1787
1911
  def schema_cache; end
1788
1912
  def schema_cache=(cache); end
1789
1913
  def schema_migration; end
@@ -1791,16 +1915,17 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
1791
1915
  def steal!; end
1792
1916
  def supports_advisory_locks?; end
1793
1917
  def supports_bulk_alter?; end
1918
+ def supports_check_constraints?; end
1794
1919
  def supports_comments?; end
1795
1920
  def supports_comments_in_create?; end
1796
1921
  def supports_common_table_expressions?; end
1922
+ def supports_concurrent_connections?; end
1797
1923
  def supports_datetime_with_precision?; end
1798
1924
  def supports_ddl_transactions?; end
1799
1925
  def supports_explain?; end
1800
1926
  def supports_expression_index?; end
1801
1927
  def supports_extensions?; end
1802
1928
  def supports_foreign_keys?; end
1803
- def supports_foreign_keys_in_create?(*args, &block); end
1804
1929
  def supports_foreign_tables?; end
1805
1930
  def supports_index_sort_order?; end
1806
1931
  def supports_indexes_in_create?; end
@@ -1811,7 +1936,6 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
1811
1936
  def supports_json?; end
1812
1937
  def supports_lazy_transactions?; end
1813
1938
  def supports_materialized_views?; end
1814
- def supports_multi_insert?(*args, &block); end
1815
1939
  def supports_optimizer_hints?; end
1816
1940
  def supports_partial_index?; end
1817
1941
  def supports_partitioned_indexes?; end
@@ -1820,14 +1944,16 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
1820
1944
  def supports_validate_constraints?; end
1821
1945
  def supports_views?; end
1822
1946
  def supports_virtual_columns?; end
1823
- def truncate(*_); end
1824
- def truncate_tables(*_); end
1947
+ def throw_away!; end
1948
+ def truncate(*_arg0); end
1949
+ def truncate_tables(*_arg0); end
1825
1950
  def unprepared_statement; end
1826
- def update(*_); end
1951
+ def update(*_arg0); end
1827
1952
  def use_metadata_table?; end
1828
1953
  def valid_type?(type); end
1829
1954
  def verify!; end
1830
1955
  def visitor; end
1956
+ def with_instrumenter(instrumenter, &block); end
1831
1957
 
1832
1958
  private
1833
1959
 
@@ -1842,7 +1968,7 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
1842
1968
  def extract_precision(sql_type); end
1843
1969
  def extract_scale(sql_type); end
1844
1970
  def initialize_type_map(m = T.unsafe(nil)); end
1845
- def log(sql, name = T.unsafe(nil), binds = T.unsafe(nil), type_casted_binds = T.unsafe(nil), statement_name = T.unsafe(nil)); end
1971
+ def log(sql, name = T.unsafe(nil), binds = T.unsafe(nil), type_casted_binds = T.unsafe(nil), statement_name = T.unsafe(nil), async: T.unsafe(nil)); end
1846
1972
  def register_class_with_limit(mapping, key, klass); end
1847
1973
  def register_class_with_precision(mapping, key, klass); end
1848
1974
  def reload_type_map; end
@@ -1884,17 +2010,16 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter::Version
1884
2010
  def to_s; end
1885
2011
  end
1886
2012
 
1887
- module ActiveRecord::ConnectionAdapters::AbstractPool
1888
- def get_schema_cache(connection); end
1889
- def set_schema_cache(cache); end
1890
- end
1891
-
1892
2013
  class ActiveRecord::ConnectionAdapters::AlterTable
1893
2014
  def initialize(td); end
1894
2015
 
2016
+ def add_check_constraint(expression, options); end
1895
2017
  def add_column(name, type, **options); end
1896
2018
  def add_foreign_key(to_table, options); end
1897
2019
  def adds; end
2020
+ def check_constraint_adds; end
2021
+ def check_constraint_drops; end
2022
+ def drop_check_constraint(constraint_name); end
1898
2023
  def drop_foreign_key(name); end
1899
2024
  def foreign_key_adds; end
1900
2025
  def foreign_key_drops; end
@@ -1908,10 +2033,30 @@ class ActiveRecord::ConnectionAdapters::ChangeColumnDefinition < ::Struct
1908
2033
  def name=(_); end
1909
2034
 
1910
2035
  class << self
1911
- def [](*_); end
2036
+ def [](*_arg0); end
1912
2037
  def inspect; end
1913
2038
  def members; end
1914
- def new(*_); end
2039
+ def new(*_arg0); end
2040
+ end
2041
+ end
2042
+
2043
+ class ActiveRecord::ConnectionAdapters::CheckConstraintDefinition < ::Struct
2044
+ def export_name_on_schema_dump?; end
2045
+ def expression; end
2046
+ def expression=(_); end
2047
+ def name; end
2048
+ def options; end
2049
+ def options=(_); end
2050
+ def table_name; end
2051
+ def table_name=(_); end
2052
+ def validate?; end
2053
+ def validated?; end
2054
+
2055
+ class << self
2056
+ def [](*_arg0); end
2057
+ def inspect; end
2058
+ def members; end
2059
+ def new(*_arg0); end
1915
2060
  end
1916
2061
  end
1917
2062
 
@@ -1919,7 +2064,7 @@ class ActiveRecord::ConnectionAdapters::Column
1919
2064
  include(::ActiveRecord::ConnectionAdapters::Deduplicable)
1920
2065
  extend(::ActiveRecord::ConnectionAdapters::Deduplicable::ClassMethods)
1921
2066
 
1922
- def initialize(name, default, sql_type_metadata = T.unsafe(nil), null = T.unsafe(nil), default_function = T.unsafe(nil), collation: T.unsafe(nil), comment: T.unsafe(nil), **_); end
2067
+ def initialize(name, default, sql_type_metadata = T.unsafe(nil), null = T.unsafe(nil), default_function = T.unsafe(nil), collation: T.unsafe(nil), comment: T.unsafe(nil), **_arg7); end
1923
2068
 
1924
2069
  def ==(other); end
1925
2070
  def bigint?; end
@@ -1933,14 +2078,14 @@ class ActiveRecord::ConnectionAdapters::Column
1933
2078
  def hash; end
1934
2079
  def human_name; end
1935
2080
  def init_with(coder); end
1936
- def limit(*args, &block); end
2081
+ def limit(*_arg0, &_arg1); end
1937
2082
  def name; end
1938
2083
  def null; end
1939
- def precision(*args, &block); end
1940
- def scale(*args, &block); end
1941
- def sql_type(*args, &block); end
2084
+ def precision(*_arg0, &_arg1); end
2085
+ def scale(*_arg0, &_arg1); end
2086
+ def sql_type(*_arg0, &_arg1); end
1942
2087
  def sql_type_metadata; end
1943
- def type(*args, &block); end
2088
+ def type(*_arg0, &_arg1); end
1944
2089
 
1945
2090
  private
1946
2091
 
@@ -1948,6 +2093,7 @@ class ActiveRecord::ConnectionAdapters::Column
1948
2093
  end
1949
2094
 
1950
2095
  class ActiveRecord::ConnectionAdapters::ColumnDefinition < ::Struct
2096
+ def aliased_types(name, fallback); end
1951
2097
  def collation; end
1952
2098
  def collation=(value); end
1953
2099
  def comment; end
@@ -1973,32 +2119,33 @@ class ActiveRecord::ConnectionAdapters::ColumnDefinition < ::Struct
1973
2119
  def type=(_); end
1974
2120
 
1975
2121
  class << self
1976
- def [](*_); end
2122
+ def [](*_arg0); end
1977
2123
  def inspect; end
1978
2124
  def members; end
1979
- def new(*_); end
2125
+ def new(*_arg0); end
1980
2126
  end
1981
2127
  end
1982
2128
 
1983
2129
  class ActiveRecord::ConnectionAdapters::ConnectionHandler
1984
2130
  def initialize; end
1985
2131
 
1986
- def active_connections?; end
1987
- def clear_active_connections!; end
1988
- def clear_all_connections!; end
1989
- def clear_reloadable_connections!; end
1990
- def connected?(spec_name, pool_key = T.unsafe(nil)); end
1991
- def connection_pool_list; end
2132
+ def active_connections?(role = T.unsafe(nil)); end
2133
+ def all_connection_pools; end
2134
+ def clear_active_connections!(role = T.unsafe(nil)); end
2135
+ def clear_all_connections!(role = T.unsafe(nil)); end
2136
+ def clear_reloadable_connections!(role = T.unsafe(nil)); end
2137
+ def connected?(spec_name, role: T.unsafe(nil), shard: T.unsafe(nil)); end
2138
+ def connection_pool_list(role = T.unsafe(nil)); end
1992
2139
  def connection_pool_names; end
1993
- def connection_pools; end
1994
- def establish_connection(config, pool_key = T.unsafe(nil), owner_name = T.unsafe(nil)); end
1995
- def flush_idle_connections!; end
2140
+ def connection_pools(role = T.unsafe(nil)); end
2141
+ def establish_connection(config, owner_name: T.unsafe(nil), role: T.unsafe(nil), shard: T.unsafe(nil)); end
2142
+ def flush_idle_connections!(role = T.unsafe(nil)); end
1996
2143
  def prevent_writes; end
1997
2144
  def prevent_writes=(prevent_writes); end
1998
2145
  def remove_connection(*args, &block); end
1999
- def remove_connection_pool(owner, pool_key = T.unsafe(nil)); end
2000
- def retrieve_connection(spec_name, pool_key = T.unsafe(nil)); end
2001
- def retrieve_connection_pool(owner, pool_key = T.unsafe(nil)); end
2146
+ def remove_connection_pool(owner, role: T.unsafe(nil), shard: T.unsafe(nil)); end
2147
+ def retrieve_connection(spec_name, role: T.unsafe(nil), shard: T.unsafe(nil)); end
2148
+ def retrieve_connection_pool(owner, role: T.unsafe(nil), shard: T.unsafe(nil)); end
2002
2149
  def while_preventing_writes(enabled = T.unsafe(nil)); end
2003
2150
 
2004
2151
  private
@@ -2016,16 +2163,18 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool
2016
2163
  def initialize(pool_config); end
2017
2164
 
2018
2165
  def active_connection?; end
2166
+ def async_executor; end
2019
2167
  def automatic_reconnect; end
2020
- def automatic_reconnect=(_); end
2168
+ def automatic_reconnect=(_arg0); end
2021
2169
  def checkin(conn); end
2022
2170
  def checkout(checkout_timeout = T.unsafe(nil)); end
2023
2171
  def checkout_timeout; end
2024
- def checkout_timeout=(_); end
2172
+ def checkout_timeout=(_arg0); end
2025
2173
  def clear_reloadable_connections(raise_on_acquisition_timeout = T.unsafe(nil)); end
2026
2174
  def clear_reloadable_connections!; end
2027
2175
  def connected?; end
2028
2176
  def connection; end
2177
+ def connection_klass; end
2029
2178
  def connections; end
2030
2179
  def db_config; end
2031
2180
  def discard!; end
@@ -2041,7 +2190,8 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool
2041
2190
  def reaper; end
2042
2191
  def release_connection(owner_thread = T.unsafe(nil)); end
2043
2192
  def remove(conn); end
2044
- def schema_cache(*args, &block); end
2193
+ def schedule_query(future_result); end
2194
+ def schema_cache(*_arg0, &_arg1); end
2045
2195
  def schema_cache=(arg); end
2046
2196
  def size; end
2047
2197
  def stat; end
@@ -2052,6 +2202,7 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool
2052
2202
  def acquire_connection(checkout_timeout); end
2053
2203
  def adopt_connection(conn); end
2054
2204
  def attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout = T.unsafe(nil)); end
2205
+ def build_async_executor; end
2055
2206
  def bulk_make_new_connections(num_new_conns_needed); end
2056
2207
  def checkout_and_verify(c); end
2057
2208
  def checkout_for_exclusive_access(checkout_timeout); end
@@ -2127,17 +2278,10 @@ end
2127
2278
 
2128
2279
  module ActiveRecord::ConnectionAdapters::DatabaseLimits
2129
2280
  def allowed_index_name_length(*args, &block); end
2130
- def column_name_length(*args, &block); end
2131
- def columns_per_multicolumn_index(*args, &block); end
2132
- def columns_per_table(*args, &block); end
2133
2281
  def in_clause_length(*args, &block); end
2134
2282
  def index_name_length; end
2135
- def indexes_per_table(*args, &block); end
2136
- def joins_per_query(*args, &block); end
2137
2283
  def max_identifier_length; end
2138
- def sql_query_length(*args, &block); end
2139
2284
  def table_alias_length; end
2140
- def table_name_length(*args, &block); end
2141
2285
 
2142
2286
  private
2143
2287
 
@@ -2147,20 +2291,20 @@ end
2147
2291
  module ActiveRecord::ConnectionAdapters::DatabaseStatements
2148
2292
  def initialize; end
2149
2293
 
2150
- def add_transaction_record(record); end
2294
+ def add_transaction_record(record, ensure_finalize = T.unsafe(nil)); end
2151
2295
  def begin_db_transaction; end
2152
2296
  def begin_isolated_db_transaction(isolation); end
2153
- def begin_transaction(*args, &block); end
2297
+ def begin_transaction(*_arg0, &_arg1); end
2154
2298
  def cacheable_query(klass, arel); end
2155
2299
  def commit_db_transaction; end
2156
- def commit_transaction(*args, &block); end
2300
+ def commit_transaction(*_arg0, &_arg1); end
2157
2301
  def create(arel, name = T.unsafe(nil), pk = T.unsafe(nil), id_value = T.unsafe(nil), sequence_name = T.unsafe(nil), binds = T.unsafe(nil)); end
2158
- def current_transaction(*args, &block); end
2302
+ def current_transaction(*_arg0, &_arg1); end
2159
2303
  def default_sequence_name(table, column); end
2160
2304
  def delete(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
2161
- def disable_lazy_transactions!(*args, &block); end
2305
+ def disable_lazy_transactions!(*_arg0, &_arg1); end
2162
2306
  def empty_insert_statement_value(primary_key = T.unsafe(nil)); end
2163
- def enable_lazy_transactions!(*args, &block); end
2307
+ def enable_lazy_transactions!(*_arg0, &_arg1); end
2164
2308
  def exec_delete(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
2165
2309
  def exec_insert(sql, name = T.unsafe(nil), binds = T.unsafe(nil), pk = T.unsafe(nil), sequence_name = T.unsafe(nil)); end
2166
2310
  def exec_insert_all(sql, name); end
@@ -2168,11 +2312,13 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements
2168
2312
  def exec_rollback_db_transaction; end
2169
2313
  def exec_update(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
2170
2314
  def execute(sql, name = T.unsafe(nil)); end
2315
+ def explain(arel, binds = T.unsafe(nil)); end
2171
2316
  def insert(arel, name = T.unsafe(nil), pk = T.unsafe(nil), id_value = T.unsafe(nil), sequence_name = T.unsafe(nil), binds = T.unsafe(nil)); end
2172
2317
  def insert_fixture(fixture, table_name); end
2173
2318
  def insert_fixtures_set(fixture_set, tables_to_delete = T.unsafe(nil)); end
2174
- def materialize_transactions(*args, &block); end
2175
- def open_transactions(*args, &block); end
2319
+ def mark_transaction_written_if_write(sql); end
2320
+ def materialize_transactions(*_arg0, &_arg1); end
2321
+ def open_transactions(*_arg0, &_arg1); end
2176
2322
  def query(sql, name = T.unsafe(nil)); end
2177
2323
  def query_value(sql, name = T.unsafe(nil)); end
2178
2324
  def query_values(sql, name = T.unsafe(nil)); end
@@ -2180,9 +2326,9 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements
2180
2326
  def reset_transaction; end
2181
2327
  def rollback_db_transaction; end
2182
2328
  def rollback_to_savepoint(name = T.unsafe(nil)); end
2183
- def rollback_transaction(*args, &block); end
2329
+ def rollback_transaction(*_arg0, &_arg1); end
2184
2330
  def sanitize_limit(limit); end
2185
- def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil)); end
2331
+ def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil)); end
2186
2332
  def select_one(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
2187
2333
  def select_rows(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
2188
2334
  def select_value(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
@@ -2192,12 +2338,11 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements
2192
2338
  def transaction_isolation_levels; end
2193
2339
  def transaction_manager; end
2194
2340
  def transaction_open?; end
2195
- def transaction_state; end
2196
2341
  def truncate(table_name, name = T.unsafe(nil)); end
2197
2342
  def truncate_tables(*table_names); end
2198
2343
  def update(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
2199
2344
  def with_yaml_fallback(value); end
2200
- def within_new_transaction(*args, &block); end
2345
+ def within_new_transaction(*_arg0, &_arg1); end
2201
2346
  def write_query?(sql); end
2202
2347
 
2203
2348
  private
@@ -2211,8 +2356,7 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements
2211
2356
  def default_insert_value(column); end
2212
2357
  def execute_batch(statements, name = T.unsafe(nil)); end
2213
2358
  def last_inserted_id(result); end
2214
- def select(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
2215
- def select_prepared(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
2359
+ def select(sql, name = T.unsafe(nil), binds = T.unsafe(nil), prepare: T.unsafe(nil), async: T.unsafe(nil)); end
2216
2360
  def single_value_from_rows(rows); end
2217
2361
  def sql_for_insert(sql, pk, binds); end
2218
2362
  def to_sql_and_binds(arel_or_sql_string, binds = T.unsafe(nil), preparable = T.unsafe(nil)); end
@@ -2242,16 +2386,17 @@ class ActiveRecord::ConnectionAdapters::ForeignKeyDefinition < ::Struct
2242
2386
  def default_primary_key; end
2243
2387
 
2244
2388
  class << self
2245
- def [](*_); end
2389
+ def [](*_arg0); end
2246
2390
  def inspect; end
2247
2391
  def members; end
2248
- def new(*_); end
2392
+ def new(*_arg0); end
2249
2393
  end
2250
2394
  end
2251
2395
 
2252
2396
  class ActiveRecord::ConnectionAdapters::IndexDefinition
2253
2397
  def initialize(table, name, unique = T.unsafe(nil), columns = T.unsafe(nil), lengths: T.unsafe(nil), orders: T.unsafe(nil), opclasses: T.unsafe(nil), where: T.unsafe(nil), type: T.unsafe(nil), using: T.unsafe(nil), comment: T.unsafe(nil)); end
2254
2398
 
2399
+ def column_options; end
2255
2400
  def columns; end
2256
2401
  def comment; end
2257
2402
  def lengths; end
@@ -2269,17 +2414,28 @@ class ActiveRecord::ConnectionAdapters::IndexDefinition
2269
2414
  def concise_options(options); end
2270
2415
  end
2271
2416
 
2417
+ class ActiveRecord::ConnectionAdapters::LegacyPoolManager
2418
+ def initialize; end
2419
+
2420
+ def get_pool_config(_, shard); end
2421
+ def pool_configs(_ = T.unsafe(nil)); end
2422
+ def remove_pool_config(_, shard); end
2423
+ def set_pool_config(_, shard, pool_config); end
2424
+ def shard_names; end
2425
+ end
2426
+
2272
2427
  class ActiveRecord::ConnectionAdapters::NullPool
2273
2428
  include(::ActiveRecord::ConnectionAdapters::AbstractPool)
2274
2429
 
2430
+ def connection_klass; end
2275
2431
  def schema_cache; end
2276
- def schema_cache=(_); end
2432
+ def schema_cache=(_arg0); end
2277
2433
  end
2278
2434
 
2279
2435
  class ActiveRecord::ConnectionAdapters::NullTransaction
2280
2436
  def initialize; end
2281
2437
 
2282
- def add_record(record); end
2438
+ def add_record(record, _ = T.unsafe(nil)); end
2283
2439
  def closed?; end
2284
2440
  def joinable?; end
2285
2441
  def open?; end
@@ -2289,8 +2445,9 @@ end
2289
2445
  class ActiveRecord::ConnectionAdapters::PoolConfig
2290
2446
  include(::Mutex_m)
2291
2447
 
2292
- def initialize(connection_specification_name, db_config); end
2448
+ def initialize(connection_klass, db_config); end
2293
2449
 
2450
+ def connection_klass; end
2294
2451
  def connection_specification_name; end
2295
2452
  def db_config; end
2296
2453
  def discard_pool!; end
@@ -2299,7 +2456,7 @@ class ActiveRecord::ConnectionAdapters::PoolConfig
2299
2456
  def locked?; end
2300
2457
  def pool; end
2301
2458
  def schema_cache; end
2302
- def schema_cache=(_); end
2459
+ def schema_cache=(_arg0); end
2303
2460
  def synchronize(&block); end
2304
2461
  def try_lock; end
2305
2462
  def unlock; end
@@ -2312,14 +2469,17 @@ end
2312
2469
  class ActiveRecord::ConnectionAdapters::PoolManager
2313
2470
  def initialize; end
2314
2471
 
2315
- def get_pool_config(key); end
2316
- def pool_configs; end
2317
- def remove_pool_config(key); end
2318
- def set_pool_config(key, pool_config); end
2472
+ def get_pool_config(role, shard); end
2473
+ def pool_configs(role = T.unsafe(nil)); end
2474
+ def remove_pool_config(role, shard); end
2475
+ def remove_role(role); end
2476
+ def role_names; end
2477
+ def set_pool_config(role, shard, pool_config); end
2478
+ def shard_names; end
2319
2479
  end
2320
2480
 
2321
2481
  module ActiveRecord::ConnectionAdapters::QueryCache
2322
- def initialize(*_); end
2482
+ def initialize(*_arg0); end
2323
2483
 
2324
2484
  def cache; end
2325
2485
  def clear_query_cache; end
@@ -2327,7 +2487,7 @@ module ActiveRecord::ConnectionAdapters::QueryCache
2327
2487
  def enable_query_cache!; end
2328
2488
  def query_cache; end
2329
2489
  def query_cache_enabled; end
2330
- def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil)); end
2490
+ def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil)); end
2331
2491
  def uncached; end
2332
2492
 
2333
2493
  private
@@ -2335,7 +2495,7 @@ module ActiveRecord::ConnectionAdapters::QueryCache
2335
2495
  def cache_notification_info(sql, name, binds); end
2336
2496
  def cache_sql(sql, name, binds); end
2337
2497
  def configure_query_cache!; end
2338
- def locked?(arel); end
2498
+ def lookup_sql_cache(sql, name, binds); end
2339
2499
 
2340
2500
  class << self
2341
2501
  def dirties_query_cache(base, *method_names); end
@@ -2344,7 +2504,7 @@ module ActiveRecord::ConnectionAdapters::QueryCache
2344
2504
  end
2345
2505
 
2346
2506
  module ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration
2347
- def initialize(*_); end
2507
+ def initialize(*_arg0); end
2348
2508
 
2349
2509
  def disable_query_cache!; end
2350
2510
  def enable_query_cache!; end
@@ -2375,7 +2535,6 @@ module ActiveRecord::ConnectionAdapters::Quoting
2375
2535
 
2376
2536
  def _quote(value); end
2377
2537
  def _type_cast(value); end
2378
- def id_value_for_database(value); end
2379
2538
  def lookup_cast_type(sql_type); end
2380
2539
  def type_casted_binds(binds); end
2381
2540
  end
@@ -2401,10 +2560,11 @@ class ActiveRecord::ConnectionAdapters::ReferenceDefinition
2401
2560
  def foreign_key_options; end
2402
2561
  def foreign_table_name; end
2403
2562
  def index; end
2404
- def index_options; end
2563
+ def index_options(table_name); end
2405
2564
  def name; end
2406
2565
  def options; end
2407
2566
  def polymorphic; end
2567
+ def polymorphic_index_name(table_name); end
2408
2568
  def polymorphic_options; end
2409
2569
  def type; end
2410
2570
  end
@@ -2429,19 +2589,23 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
2429
2589
  include(::ActiveRecord::Migration::JoinTable)
2430
2590
 
2431
2591
  def add_belongs_to(table_name, ref_name, **options); end
2592
+ def add_check_constraint(table_name, expression, **options); end
2432
2593
  def add_column(table_name, column_name, type, **options); end
2594
+ def add_columns(table_name, *column_names, type:, **options); end
2433
2595
  def add_foreign_key(from_table, to_table, **options); end
2434
- def add_index(table_name, column_name, options = T.unsafe(nil)); end
2435
- def add_index_options(table_name, column_name, comment: T.unsafe(nil), **options); end
2596
+ def add_index(table_name, column_name, **options); end
2597
+ def add_index_options(table_name, column_name, name: T.unsafe(nil), if_not_exists: T.unsafe(nil), internal: T.unsafe(nil), **options); end
2436
2598
  def add_reference(table_name, ref_name, **options); end
2437
2599
  def add_timestamps(table_name, **options); end
2438
- def assume_migrated_upto_version(version, migrations_paths = T.unsafe(nil)); end
2439
- def change_column(table_name, column_name, type, options = T.unsafe(nil)); end
2600
+ def assume_migrated_upto_version(version); end
2601
+ def change_column(table_name, column_name, type, **options); end
2440
2602
  def change_column_comment(table_name, column_name, comment_or_changes); end
2441
2603
  def change_column_default(table_name, column_name, default_or_changes); end
2442
2604
  def change_column_null(table_name, column_name, null, default = T.unsafe(nil)); end
2443
2605
  def change_table(table_name, **options); end
2444
2606
  def change_table_comment(table_name, comment_or_changes); end
2607
+ def check_constraint_options(table_name, expression, options); end
2608
+ def check_constraints(table_name); end
2445
2609
  def column_exists?(table_name, column_name, type = T.unsafe(nil), **options); end
2446
2610
  def columns(table_name); end
2447
2611
  def columns_for_distinct(columns, orders); end
@@ -2450,6 +2614,7 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
2450
2614
  def create_table(table_name, id: T.unsafe(nil), primary_key: T.unsafe(nil), force: T.unsafe(nil), **options); end
2451
2615
  def data_source_exists?(name); end
2452
2616
  def data_sources; end
2617
+ def distinct_relation_for_primary_key(relation); end
2453
2618
  def drop_join_table(table_1, table_2, **options); end
2454
2619
  def drop_table(table_name, **options); end
2455
2620
  def dump_schema_information; end
@@ -2457,7 +2622,8 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
2457
2622
  def foreign_key_exists?(from_table, to_table = T.unsafe(nil), **options); end
2458
2623
  def foreign_key_options(from_table, to_table, options); end
2459
2624
  def foreign_keys(table_name); end
2460
- def index_exists?(table_name, column_name, options = T.unsafe(nil)); end
2625
+ def index_algorithm(algorithm); end
2626
+ def index_exists?(table_name, column_name, **options); end
2461
2627
  def index_name(table_name, options); end
2462
2628
  def index_name_exists?(table_name, index_name); end
2463
2629
  def indexes(table_name); end
@@ -2465,11 +2631,13 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
2465
2631
  def native_database_types; end
2466
2632
  def options_include_default?(options); end
2467
2633
  def primary_key(table_name); end
2634
+ def quoted_columns_for_index(column_names, options); end
2468
2635
  def remove_belongs_to(table_name, ref_name, foreign_key: T.unsafe(nil), polymorphic: T.unsafe(nil), **options); end
2636
+ def remove_check_constraint(table_name, expression = T.unsafe(nil), **options); end
2469
2637
  def remove_column(table_name, column_name, type = T.unsafe(nil), **options); end
2470
- def remove_columns(table_name, *column_names, **options); end
2638
+ def remove_columns(table_name, *column_names, type: T.unsafe(nil), **options); end
2471
2639
  def remove_foreign_key(from_table, to_table = T.unsafe(nil), **options); end
2472
- def remove_index(table_name, column_name = T.unsafe(nil), options = T.unsafe(nil)); end
2640
+ def remove_index(table_name, column_name = T.unsafe(nil), **options); end
2473
2641
  def remove_reference(table_name, ref_name, foreign_key: T.unsafe(nil), polymorphic: T.unsafe(nil), **options); end
2474
2642
  def remove_timestamps(table_name, **options); end
2475
2643
  def rename_column(table_name, column_name, new_column_name); end
@@ -2480,7 +2648,7 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
2480
2648
  def table_exists?(table_name); end
2481
2649
  def table_options(table_name); end
2482
2650
  def tables; end
2483
- def type_to_sql(type, limit: T.unsafe(nil), precision: T.unsafe(nil), scale: T.unsafe(nil), **_); end
2651
+ def type_to_sql(type, limit: T.unsafe(nil), precision: T.unsafe(nil), scale: T.unsafe(nil), **_arg4); end
2484
2652
  def update_table_definition(table_name, base); end
2485
2653
  def view_exists?(view_name); end
2486
2654
  def views; end
@@ -2493,13 +2661,17 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
2493
2661
  def add_timestamps_for_alter(table_name, **options); end
2494
2662
  def bulk_change_table(table_name, operations); end
2495
2663
  def can_remove_index_by_name?(column_name, options); end
2664
+ def check_constraint_for(table_name, **options); end
2665
+ def check_constraint_for!(table_name, expression: T.unsafe(nil), **options); end
2666
+ def check_constraint_name(table_name, **options); end
2496
2667
  def column_options_keys; end
2497
2668
  def create_alter_table(name); end
2498
- def create_table_definition(*args, **options); end
2669
+ def create_table_definition(name, **options); end
2499
2670
  def data_source_sql(name = T.unsafe(nil), type: T.unsafe(nil)); end
2500
2671
  def extract_foreign_key_action(specifier); end
2501
2672
  def extract_new_comment_value(default_or_changes); end
2502
2673
  def extract_new_default_value(default_or_changes); end
2674
+ def extract_table_options!(options); end
2503
2675
  def fetch_type_metadata(sql_type); end
2504
2676
  def foreign_key_for(from_table, **options); end
2505
2677
  def foreign_key_for!(from_table, to_table: T.unsafe(nil), **options); end
@@ -2509,12 +2681,12 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
2509
2681
  def index_name_options(column_names); end
2510
2682
  def insert_versions_sql(versions); end
2511
2683
  def options_for_index_columns(options); end
2512
- def quoted_columns_for_index(column_names, **options); end
2513
2684
  def quoted_scope(name = T.unsafe(nil), type: T.unsafe(nil)); end
2514
2685
  def remove_column_for_alter(table_name, column_name, type = T.unsafe(nil), **options); end
2515
2686
  def remove_columns_for_alter(table_name, *column_names, **options); end
2516
2687
  def remove_timestamps_for_alter(table_name, **options); end
2517
2688
  def rename_column_indexes(table_name, column_name, new_column_name); end
2689
+ def rename_column_sql(table_name, column_name, new_column_name); end
2518
2690
  def rename_table_indexes(table_name, new_name); end
2519
2691
  def schema_creation; end
2520
2692
  def strip_table_name_prefix_and_suffix(table_name); end
@@ -2530,11 +2702,13 @@ class ActiveRecord::ConnectionAdapters::Table
2530
2702
  def belongs_to(*args, **options); end
2531
2703
  def bigint(*names, **options); end
2532
2704
  def binary(*names, **options); end
2705
+ def blob(*names, **options); end
2533
2706
  def boolean(*names, **options); end
2534
- def change(column_name, type, options = T.unsafe(nil)); end
2707
+ def change(column_name, type, **options); end
2535
2708
  def change_default(column_name, default_or_changes); end
2536
2709
  def change_null(column_name, null, default = T.unsafe(nil)); end
2537
- def column(column_name, type, **options); end
2710
+ def check_constraint(*args); end
2711
+ def column(column_name, type, index: T.unsafe(nil), **options); end
2538
2712
  def column_exists?(column_name, type = T.unsafe(nil), **options); end
2539
2713
  def date(*names, **options); end
2540
2714
  def datetime(*names, **options); end
@@ -2542,7 +2716,7 @@ class ActiveRecord::ConnectionAdapters::Table
2542
2716
  def float(*names, **options); end
2543
2717
  def foreign_key(*args, **options); end
2544
2718
  def foreign_key_exists?(*args, **options); end
2545
- def index(column_name, options = T.unsafe(nil)); end
2719
+ def index(column_name, **options); end
2546
2720
  def index_exists?(column_name, options = T.unsafe(nil)); end
2547
2721
  def integer(*names, **options); end
2548
2722
  def json(*names, **options); end
@@ -2551,8 +2725,9 @@ class ActiveRecord::ConnectionAdapters::Table
2551
2725
  def references(*args, **options); end
2552
2726
  def remove(*column_names, **options); end
2553
2727
  def remove_belongs_to(*args, **options); end
2728
+ def remove_check_constraint(*args); end
2554
2729
  def remove_foreign_key(*args, **options); end
2555
- def remove_index(column_name = T.unsafe(nil), options = T.unsafe(nil)); end
2730
+ def remove_index(column_name = T.unsafe(nil), **options); end
2556
2731
  def remove_references(*args, **options); end
2557
2732
  def remove_timestamps(**options); end
2558
2733
  def rename(column_name, new_column_name); end
@@ -2569,15 +2744,18 @@ class ActiveRecord::ConnectionAdapters::TableDefinition
2569
2744
  include(::ActiveRecord::ConnectionAdapters::ColumnMethods)
2570
2745
  extend(::ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods)
2571
2746
 
2572
- def initialize(conn, name, temporary: T.unsafe(nil), if_not_exists: T.unsafe(nil), options: T.unsafe(nil), as: T.unsafe(nil), comment: T.unsafe(nil)); end
2747
+ def initialize(conn, name, temporary: T.unsafe(nil), if_not_exists: T.unsafe(nil), options: T.unsafe(nil), as: T.unsafe(nil), comment: T.unsafe(nil), **_arg7); end
2573
2748
 
2574
2749
  def [](name); end
2575
2750
  def as; end
2576
2751
  def belongs_to(*args, **options); end
2577
2752
  def bigint(*names, **options); end
2578
2753
  def binary(*names, **options); end
2754
+ def blob(*names, **options); end
2579
2755
  def boolean(*names, **options); end
2580
- def column(name, type, **options); end
2756
+ def check_constraint(expression, **options); end
2757
+ def check_constraints; end
2758
+ def column(name, type, index: T.unsafe(nil), **options); end
2581
2759
  def columns; end
2582
2760
  def comment; end
2583
2761
  def date(*names, **options); end
@@ -2587,7 +2765,7 @@ class ActiveRecord::ConnectionAdapters::TableDefinition
2587
2765
  def foreign_key(table_name, **options); end
2588
2766
  def foreign_keys; end
2589
2767
  def if_not_exists; end
2590
- def index(column_name, options = T.unsafe(nil)); end
2768
+ def index(column_name, **options); end
2591
2769
  def indexes; end
2592
2770
  def integer(*names, **options); end
2593
2771
  def json(*names, **options); end
@@ -2654,36 +2832,38 @@ class ActiveRecord::ConnectionAdapters::TransactionState
2654
2832
  end
2655
2833
 
2656
2834
  module ActiveRecord::ConnectionHandling
2657
- def clear_active_connections!(*args, &block); end
2658
- def clear_all_connections!(*args, &block); end
2835
+ def clear_active_connections!(*_arg0, &_arg1); end
2836
+ def clear_all_connections!(*_arg0, &_arg1); end
2659
2837
  def clear_cache!; end
2660
2838
  def clear_query_caches_for_current_thread; end
2661
- def clear_reloadable_connections!(*args, &block); end
2839
+ def clear_reloadable_connections!(*_arg0, &_arg1); end
2662
2840
  def connected?; end
2663
- def connected_to(database: T.unsafe(nil), role: T.unsafe(nil), shard: T.unsafe(nil), prevent_writes: T.unsafe(nil), &blk); end
2841
+ def connected_to(role: T.unsafe(nil), shard: T.unsafe(nil), prevent_writes: T.unsafe(nil), &blk); end
2664
2842
  def connected_to?(role:, shard: T.unsafe(nil)); end
2843
+ def connected_to_many(*classes, role:, shard: T.unsafe(nil), prevent_writes: T.unsafe(nil)); end
2844
+ def connecting_to(role: T.unsafe(nil), shard: T.unsafe(nil), prevent_writes: T.unsafe(nil)); end
2665
2845
  def connection; end
2666
2846
  def connection_config(*args, &block); end
2667
2847
  def connection_db_config; end
2668
2848
  def connection_pool; end
2669
2849
  def connection_specification_name; end
2670
- def connection_specification_name=(_); end
2850
+ def connection_specification_name=(_arg0); end
2671
2851
  def connects_to(database: T.unsafe(nil), shards: T.unsafe(nil)); end
2672
- def current_role; end
2673
2852
  def establish_connection(config_or_env = T.unsafe(nil)); end
2674
- def flush_idle_connections!(*args, &block); end
2853
+ def flush_idle_connections!(*_arg0, &_arg1); end
2675
2854
  def lookup_connection_handler(handler_key); end
2676
2855
  def primary_class?; end
2677
2856
  def remove_connection(name = T.unsafe(nil)); end
2678
2857
  def retrieve_connection; end
2858
+ def while_preventing_writes(enabled = T.unsafe(nil), &block); end
2679
2859
 
2680
2860
  private
2681
2861
 
2862
+ def clear_on_handler(handler); end
2682
2863
  def resolve_config_for_connection(config_or_env); end
2683
2864
  def swap_connection_handler(handler, &blk); end
2684
2865
  def with_handler(handler_key, &blk); end
2685
- def with_role(role, prevent_writes, &blk); end
2686
- def with_shard(pool_key, role, prevent_writes); end
2866
+ def with_role_and_shard(role, shard, prevent_writes); end
2687
2867
  end
2688
2868
 
2689
2869
  ActiveRecord::ConnectionHandling::DEFAULT_ENV = T.let(T.unsafe(nil), Proc)
@@ -2720,8 +2900,10 @@ module ActiveRecord::Core
2720
2900
  def readonly!; end
2721
2901
  def readonly?; end
2722
2902
  def slice(*methods); end
2723
- def strict_loading!; end
2903
+ def strict_loading!(value = T.unsafe(nil), mode: T.unsafe(nil)); end
2724
2904
  def strict_loading?; end
2905
+ def strict_loading_n_plus_one_only?; end
2906
+ def values_at(*methods); end
2725
2907
 
2726
2908
  private
2727
2909
 
@@ -2735,11 +2917,11 @@ end
2735
2917
 
2736
2918
  module ActiveRecord::Core::ClassMethods
2737
2919
  def ===(object); end
2738
- def _internal?; end
2739
- def arel_attribute(name, table = T.unsafe(nil)); end
2920
+ def arel_attribute(*args, &block); end
2740
2921
  def arel_table; end
2922
+ def cached_find_by_statement(key, &block); end
2741
2923
  def filter_attributes; end
2742
- def filter_attributes=(_); end
2924
+ def filter_attributes=(filter_attributes); end
2743
2925
  def find(*ids); end
2744
2926
  def find_by(*args); end
2745
2927
  def find_by!(*args); end
@@ -2748,12 +2930,12 @@ module ActiveRecord::Core::ClassMethods
2748
2930
  def initialize_find_by_cache; end
2749
2931
  def initialize_generated_modules; end
2750
2932
  def inspect; end
2933
+ def inspection_filter; end
2751
2934
  def predicate_builder; end
2752
2935
  def type_caster; end
2753
2936
 
2754
2937
  private
2755
2938
 
2756
- def cached_find_by_statement(key, &block); end
2757
2939
  def relation; end
2758
2940
  def table_metadata; end
2759
2941
  end
@@ -2788,15 +2970,14 @@ class ActiveRecord::DatabaseConfigurations
2788
2970
  def initialize(configurations = T.unsafe(nil)); end
2789
2971
 
2790
2972
  def [](*args, &block); end
2791
- def any?(*args, &block); end
2973
+ def any?(*_arg0, &_arg1); end
2792
2974
  def blank?; end
2793
2975
  def configs_for(env_name: T.unsafe(nil), spec_name: T.unsafe(nil), name: T.unsafe(nil), include_replicas: T.unsafe(nil)); end
2794
2976
  def configurations; end
2795
2977
  def default_hash(*args, &block); end
2796
- def each; end
2797
2978
  def empty?; end
2798
2979
  def find_db_config(env); end
2799
- def first; end
2980
+ def primary?(name); end
2800
2981
  def resolve(config); end
2801
2982
  def to_h(*args, &block); end
2802
2983
 
@@ -2812,10 +2993,7 @@ class ActiveRecord::DatabaseConfigurations
2812
2993
  def environment_url_config(env, name, config); end
2813
2994
  def environment_value_for(name); end
2814
2995
  def merge_db_environment_variables(current_env, configs); end
2815
- def method_missing(method, *args, &blk); end
2816
2996
  def resolve_symbol_connection(name); end
2817
- def throw_getter_deprecation(method); end
2818
- def throw_setter_deprecation(method); end
2819
2997
  def walk_configs(env_name, config); end
2820
2998
  end
2821
2999
 
@@ -2846,10 +3024,13 @@ class ActiveRecord::DatabaseConfigurations::DatabaseConfig
2846
3024
  def for_current_env?; end
2847
3025
  def host; end
2848
3026
  def idle_timeout; end
3027
+ def max_queue; end
3028
+ def max_threads; end
2849
3029
  def migrations_paths; end
3030
+ def min_threads; end
2850
3031
  def name; end
2851
3032
  def owner_name; end
2852
- def owner_name=(_); end
3033
+ def owner_name=(_arg0); end
2853
3034
  def pool; end
2854
3035
  def reaping_frequency; end
2855
3036
  def replica?; end
@@ -2868,7 +3049,10 @@ class ActiveRecord::DatabaseConfigurations::HashConfig < ::ActiveRecord::Databas
2868
3049
  def database; end
2869
3050
  def host; end
2870
3051
  def idle_timeout; end
3052
+ def max_queue; end
3053
+ def max_threads; end
2871
3054
  def migrations_paths; end
3055
+ def min_threads; end
2872
3056
  def pool; end
2873
3057
  def reaping_frequency; end
2874
3058
  def replica?; end
@@ -2891,37 +3075,45 @@ end
2891
3075
  class ActiveRecord::Deadlocked < ::ActiveRecord::TransactionRollbackError
2892
3076
  end
2893
3077
 
3078
+ module ActiveRecord::DelegatedType
3079
+ def delegated_type(role, types:, **options); end
3080
+
3081
+ private
3082
+
3083
+ def define_delegated_type_methods(role, types:, options:); end
3084
+ end
3085
+
2894
3086
  module ActiveRecord::Delegation
2895
3087
  extend(::ActiveSupport::Concern)
2896
3088
 
2897
3089
  mixes_in_class_methods(::ActiveRecord::Delegation::ClassMethods)
2898
3090
 
2899
- def &(*args, &block); end
2900
- def +(*args, &block); end
2901
- def -(*args, &block); end
2902
- def [](*args, &block); end
2903
- def as_json(*args, &block); end
2904
- def compact(*args, &block); end
2905
- def connection(*args, &block); end
2906
- def each(*args, &block); end
2907
- def encode_with(*args, &block); end
2908
- def in_groups(*args, &block); end
2909
- def in_groups_of(*args, &block); end
2910
- def index(*args, &block); end
2911
- def join(*args, &block); end
2912
- def length(*args, &block); end
2913
- def primary_key(*args, &block); end
2914
- def reverse(*args, &block); end
2915
- def rindex(*args, &block); end
2916
- def rotate(*args, &block); end
2917
- def sample(*args, &block); end
2918
- def shuffle(*args, &block); end
2919
- def slice(*args, &block); end
2920
- def split(*args, &block); end
2921
- def to_formatted_s(*args, &block); end
2922
- def to_sentence(*args, &block); end
2923
- def to_xml(*args, &block); end
2924
- def |(*args, &block); end
3091
+ def &(*_arg0, &_arg1); end
3092
+ def +(*_arg0, &_arg1); end
3093
+ def -(*_arg0, &_arg1); end
3094
+ def [](*_arg0, &_arg1); end
3095
+ def as_json(*_arg0, &_arg1); end
3096
+ def compact(*_arg0, &_arg1); end
3097
+ def connection(*_arg0, &_arg1); end
3098
+ def each(*_arg0, &_arg1); end
3099
+ def encode_with(*_arg0, &_arg1); end
3100
+ def in_groups(*_arg0, &_arg1); end
3101
+ def in_groups_of(*_arg0, &_arg1); end
3102
+ def index(*_arg0, &_arg1); end
3103
+ def join(*_arg0, &_arg1); end
3104
+ def length(*_arg0, &_arg1); end
3105
+ def primary_key(*_arg0, &_arg1); end
3106
+ def reverse(*_arg0, &_arg1); end
3107
+ def rindex(*_arg0, &_arg1); end
3108
+ def rotate(*_arg0, &_arg1); end
3109
+ def sample(*_arg0, &_arg1); end
3110
+ def shuffle(*_arg0, &_arg1); end
3111
+ def slice(*_arg0, &_arg1); end
3112
+ def split(*_arg0, &_arg1); end
3113
+ def to_formatted_s(*_arg0, &_arg1); end
3114
+ def to_sentence(*_arg0, &_arg1); end
3115
+ def to_xml(*_arg0, &_arg1); end
3116
+ def |(*_arg0, &_arg1); end
2925
3117
 
2926
3118
  private
2927
3119
 
@@ -2970,6 +3162,19 @@ class ActiveRecord::DeleteRestrictionError < ::ActiveRecord::ActiveRecordError
2970
3162
  def initialize(name = T.unsafe(nil)); end
2971
3163
  end
2972
3164
 
3165
+ class ActiveRecord::DestroyAssociationAsyncJob < ::ActiveJob::Base
3166
+ def perform(owner_model_name: T.unsafe(nil), owner_id: T.unsafe(nil), association_class: T.unsafe(nil), association_ids: T.unsafe(nil), association_primary_key_column: T.unsafe(nil), ensuring_owner_was_method: T.unsafe(nil)); end
3167
+
3168
+ private
3169
+
3170
+ def owner_destroyed?(owner, ensuring_owner_was_method); end
3171
+
3172
+ class << self
3173
+ def queue_name; end
3174
+ def rescue_handlers; end
3175
+ end
3176
+ end
3177
+
2973
3178
  module ActiveRecord::DynamicMatchers
2974
3179
 
2975
3180
  private
@@ -3025,15 +3230,16 @@ class ActiveRecord::EagerLoadPolymorphicError < ::ActiveRecord::ActiveRecordErro
3025
3230
  end
3026
3231
 
3027
3232
  module ActiveRecord::Enum
3028
- def enum(definitions); end
3233
+ def enum(name = T.unsafe(nil), values = T.unsafe(nil), **options); end
3029
3234
  def inherited(base); end
3030
3235
 
3031
3236
  private
3032
3237
 
3238
+ def _enum(name, values, prefix: T.unsafe(nil), suffix: T.unsafe(nil), scopes: T.unsafe(nil), **options); end
3033
3239
  def _enum_methods_module; end
3034
3240
  def assert_valid_enum_definition_values(values); end
3035
3241
  def detect_enum_conflict!(enum_name, method_name, klass_method = T.unsafe(nil)); end
3036
- def detect_negative_condition!(method_name); end
3242
+ def detect_negative_enum_conditions!(method_names); end
3037
3243
  def raise_conflict_error(enum_name, method_name, type: T.unsafe(nil), source: T.unsafe(nil)); end
3038
3244
 
3039
3245
  class << self
@@ -3047,16 +3253,15 @@ class ActiveRecord::Enum::EnumType < ::ActiveModel::Type::Value
3047
3253
  def assert_valid_value(value); end
3048
3254
  def cast(value); end
3049
3255
  def deserialize(value); end
3050
- def serializable?(value); end
3256
+ def serializable?(value, &block); end
3051
3257
  def serialize(value); end
3052
- def type(*args, &block); end
3053
- def unchecked_serialize(value); end
3258
+ def subtype; end
3259
+ def type(*_arg0, &_arg1); end
3054
3260
 
3055
3261
  private
3056
3262
 
3057
3263
  def mapping; end
3058
3264
  def name; end
3059
- def subtype; end
3060
3265
  end
3061
3266
 
3062
3267
  class ActiveRecord::ExclusiveConnectionTimeoutError < ::ActiveRecord::ConnectionTimeoutError
@@ -3077,10 +3282,10 @@ class ActiveRecord::ExplainRegistry
3077
3282
  def initialize; end
3078
3283
 
3079
3284
  def collect; end
3080
- def collect=(_); end
3285
+ def collect=(_arg0); end
3081
3286
  def collect?; end
3082
3287
  def queries; end
3083
- def queries=(_); end
3288
+ def queries=(_arg0); end
3084
3289
  def reset; end
3085
3290
  end
3086
3291
 
@@ -3101,19 +3306,23 @@ module ActiveRecord::FinderMethods
3101
3306
  def find(*args); end
3102
3307
  def find_by(arg, *args); end
3103
3308
  def find_by!(arg, *args); end
3309
+ def find_sole_by(arg, *args); end
3104
3310
  def first(limit = T.unsafe(nil)); end
3105
3311
  def first!; end
3106
3312
  def forty_two; end
3107
3313
  def forty_two!; end
3108
3314
  def fourth; end
3109
3315
  def fourth!; end
3316
+ def include?(record); end
3110
3317
  def last(limit = T.unsafe(nil)); end
3111
3318
  def last!; end
3319
+ def member?(record); end
3112
3320
  def raise_record_not_found_exception!(ids = T.unsafe(nil), result_size = T.unsafe(nil), expected_size = T.unsafe(nil), key = T.unsafe(nil), not_found_ids = T.unsafe(nil)); end
3113
3321
  def second; end
3114
3322
  def second!; end
3115
3323
  def second_to_last; end
3116
3324
  def second_to_last!; end
3325
+ def sole; end
3117
3326
  def take(limit = T.unsafe(nil)); end
3118
3327
  def take!; end
3119
3328
  def third; end
@@ -3124,6 +3333,7 @@ module ActiveRecord::FinderMethods
3124
3333
  private
3125
3334
 
3126
3335
  def apply_join_dependency(eager_loading: T.unsafe(nil)); end
3336
+ def check_reorder_deprecation; end
3127
3337
  def construct_relation_for_exists(conditions); end
3128
3338
  def find_last(limit); end
3129
3339
  def find_nth(index); end
@@ -3135,16 +3345,55 @@ module ActiveRecord::FinderMethods
3135
3345
  def find_take; end
3136
3346
  def find_take_with_limit(limit); end
3137
3347
  def find_with_ids(*ids); end
3138
- def limited_ids_for(relation); end
3139
- def offset_index; end
3140
3348
  def ordered_relation; end
3141
3349
  def using_limitable_reflections?(reflections); end
3142
3350
  end
3143
3351
 
3144
3352
  ActiveRecord::FinderMethods::ONE_AS_ONE = T.let(T.unsafe(nil), String)
3145
3353
 
3354
+ class ActiveRecord::FutureResult
3355
+ def initialize(pool, *args, **kwargs); end
3356
+
3357
+ def cancel; end
3358
+ def empty?(*_arg0, &_arg1); end
3359
+ def execute!(connection); end
3360
+ def execute_or_skip; end
3361
+ def pending?; end
3362
+ def result; end
3363
+ def schedule!(session); end
3364
+ def to_a(*_arg0, &_arg1); end
3365
+
3366
+ private
3367
+
3368
+ def canceled?; end
3369
+ def exec_query(connection, *args, **kwargs); end
3370
+ def execute_or_wait; end
3371
+ def execute_query(connection, async: T.unsafe(nil)); end
3372
+ end
3373
+
3374
+ class ActiveRecord::FutureResult::Canceled < ::ActiveRecord::ActiveRecordError
3375
+ end
3376
+
3377
+ class ActiveRecord::FutureResult::SelectAll < ::ActiveRecord::FutureResult
3378
+
3379
+ private
3380
+
3381
+ def exec_query(*_arg0, **_arg1); end
3382
+ end
3383
+
3146
3384
  class ActiveRecord::HasManyThroughAssociationNotFoundError < ::ActiveRecord::ActiveRecordError
3147
- def initialize(owner_class_name = T.unsafe(nil), reflection = T.unsafe(nil)); end
3385
+ include(::DidYouMean::Correctable)
3386
+
3387
+ def initialize(owner_class = T.unsafe(nil), reflection = T.unsafe(nil)); end
3388
+
3389
+ def owner_class; end
3390
+ def reflection; end
3391
+ end
3392
+
3393
+ class ActiveRecord::HasManyThroughAssociationNotFoundError::Correction
3394
+ def initialize(error); end
3395
+
3396
+ def corrections; end
3148
3397
  end
3149
3398
 
3150
3399
  class ActiveRecord::HasManyThroughAssociationPointlessSourceTypeError < ::ActiveRecord::ActiveRecordError
@@ -3205,7 +3454,7 @@ end
3205
3454
 
3206
3455
  module ActiveRecord::Inheritance::ClassMethods
3207
3456
  def abstract_class; end
3208
- def abstract_class=(_); end
3457
+ def abstract_class=(_arg0); end
3209
3458
  def abstract_class?; end
3210
3459
  def base_class; end
3211
3460
  def base_class?; end
@@ -3215,6 +3464,7 @@ module ActiveRecord::Inheritance::ClassMethods
3215
3464
  def new(attributes = T.unsafe(nil), &block); end
3216
3465
  def polymorphic_class_for(name); end
3217
3466
  def polymorphic_name; end
3467
+ def primary_abstract_class; end
3218
3468
  def sti_class_for(type_name); end
3219
3469
  def sti_name; end
3220
3470
 
@@ -3265,13 +3515,13 @@ class ActiveRecord::InsertAll::Builder
3265
3515
 
3266
3516
  def conflict_target; end
3267
3517
  def into; end
3268
- def keys(*args, &block); end
3518
+ def keys(*_arg0, &_arg1); end
3269
3519
  def model; end
3270
3520
  def returning; end
3271
- def skip_duplicates?(*args, &block); end
3521
+ def skip_duplicates?(*_arg0, &_arg1); end
3272
3522
  def touch_model_timestamps_unless(&block); end
3273
3523
  def updatable_columns; end
3274
- def update_duplicates?(*args, &block); end
3524
+ def update_duplicates?(*_arg0, &_arg1); end
3275
3525
  def values_list; end
3276
3526
 
3277
3527
  private
@@ -3310,9 +3560,7 @@ class ActiveRecord::InternalMetadata < ::ActiveRecord::Base
3310
3560
  class << self
3311
3561
  def [](key); end
3312
3562
  def []=(key, value); end
3313
- def _internal?; end
3314
3563
  def _validators; end
3315
- def attribute_type_decorations; end
3316
3564
  def create_table; end
3317
3565
  def defined_enums; end
3318
3566
  def drop_table; end
@@ -3326,7 +3574,18 @@ class ActiveRecord::InvalidForeignKey < ::ActiveRecord::WrappedDatabaseException
3326
3574
  end
3327
3575
 
3328
3576
  class ActiveRecord::InverseOfAssociationNotFoundError < ::ActiveRecord::ActiveRecordError
3577
+ include(::DidYouMean::Correctable)
3578
+
3329
3579
  def initialize(reflection = T.unsafe(nil), associated_class = T.unsafe(nil)); end
3580
+
3581
+ def associated_class; end
3582
+ def reflection; end
3583
+ end
3584
+
3585
+ class ActiveRecord::InverseOfAssociationNotFoundError::Correction
3586
+ def initialize(error); end
3587
+
3588
+ def corrections; end
3330
3589
  end
3331
3590
 
3332
3591
  class ActiveRecord::IrreversibleOrderError < ::ActiveRecord::ActiveRecordError
@@ -3362,6 +3621,10 @@ class ActiveRecord::Locking::LockingType
3362
3621
  def encode_with(coder); end
3363
3622
  def init_with(coder); end
3364
3623
  def serialize(value); end
3624
+
3625
+ class << self
3626
+ def new(subtype); end
3627
+ end
3365
3628
  end
3366
3629
 
3367
3630
  module ActiveRecord::Locking::Optimistic
@@ -3369,26 +3632,25 @@ module ActiveRecord::Locking::Optimistic
3369
3632
 
3370
3633
  mixes_in_class_methods(::ActiveRecord::Locking::Optimistic::ClassMethods)
3371
3634
 
3635
+ def increment!(*_arg0, **_arg1); end
3372
3636
  def locking_enabled?; end
3373
3637
 
3374
3638
  private
3375
3639
 
3376
3640
  def _create_record(attribute_names = T.unsafe(nil)); end
3641
+ def _lock_value_for_database(locking_column); end
3377
3642
  def _touch_row(attribute_names, time); end
3378
3643
  def _update_row(attribute_names, attempted_action = T.unsafe(nil)); end
3379
3644
  def destroy_row; end
3380
3645
  end
3381
3646
 
3382
3647
  module ActiveRecord::Locking::Optimistic::ClassMethods
3648
+ def define_attribute(name, cast_type, **_arg2); end
3383
3649
  def locking_column; end
3384
3650
  def locking_column=(value); end
3385
3651
  def locking_enabled?; end
3386
3652
  def reset_locking_column; end
3387
3653
  def update_counters(id, counters); end
3388
-
3389
- private
3390
-
3391
- def inherited(subclass); end
3392
3654
  end
3393
3655
 
3394
3656
  ActiveRecord::Locking::Optimistic::ClassMethods::DEFAULT_LOCKING_COLUMN = T.let(T.unsafe(nil), String)
@@ -3400,9 +3662,10 @@ end
3400
3662
 
3401
3663
  class ActiveRecord::LogSubscriber < ::ActiveSupport::LogSubscriber
3402
3664
  def backtrace_cleaner; end
3403
- def backtrace_cleaner=(_); end
3665
+ def backtrace_cleaner=(_arg0); end
3404
3666
  def backtrace_cleaner?; end
3405
3667
  def sql(event); end
3668
+ def strict_loading_violation(event); end
3406
3669
 
3407
3670
  private
3408
3671
 
@@ -3498,7 +3761,7 @@ class ActiveRecord::Migration
3498
3761
  def method_missing(method, *arguments, &block); end
3499
3762
  def migrate(direction); end
3500
3763
  def name; end
3501
- def name=(_); end
3764
+ def name=(_arg0); end
3502
3765
  def next_migration_number(number); end
3503
3766
  def proper_table_name(name, options = T.unsafe(nil)); end
3504
3767
  def reversible; end
@@ -3514,7 +3777,7 @@ class ActiveRecord::Migration
3514
3777
  def verbose; end
3515
3778
  def verbose=(val); end
3516
3779
  def version; end
3517
- def version=(_); end
3780
+ def version=(_arg0); end
3518
3781
  def write(text = T.unsafe(nil)); end
3519
3782
 
3520
3783
  private
@@ -3527,10 +3790,10 @@ class ActiveRecord::Migration
3527
3790
  def check_pending!(connection = T.unsafe(nil)); end
3528
3791
  def current_version; end
3529
3792
  def delegate; end
3530
- def delegate=(_); end
3793
+ def delegate=(_arg0); end
3531
3794
  def disable_ddl_transaction; end
3532
3795
  def disable_ddl_transaction!; end
3533
- def disable_ddl_transaction=(_); end
3796
+ def disable_ddl_transaction=(_arg0); end
3534
3797
  def inherited(subclass); end
3535
3798
  def load_schema_if_pending!; end
3536
3799
  def maintain_test_schema!; end
@@ -3560,6 +3823,7 @@ class ActiveRecord::Migration::CommandRecorder
3560
3823
  def initialize(delegate = T.unsafe(nil)); end
3561
3824
 
3562
3825
  def add_belongs_to(*args, &block); end
3826
+ def add_check_constraint(*args, &block); end
3563
3827
  def add_column(*args, &block); end
3564
3828
  def add_foreign_key(*args, &block); end
3565
3829
  def add_index(*args, &block); end
@@ -3572,11 +3836,11 @@ class ActiveRecord::Migration::CommandRecorder
3572
3836
  def change_table(table_name, **options); end
3573
3837
  def change_table_comment(*args, &block); end
3574
3838
  def commands; end
3575
- def commands=(_); end
3839
+ def commands=(_arg0); end
3576
3840
  def create_join_table(*args, &block); end
3577
3841
  def create_table(*args, &block); end
3578
3842
  def delegate; end
3579
- def delegate=(_); end
3843
+ def delegate=(_arg0); end
3580
3844
  def disable_extension(*args, &block); end
3581
3845
  def drop_join_table(*args, &block); end
3582
3846
  def drop_table(*args, &block); end
@@ -3588,6 +3852,7 @@ class ActiveRecord::Migration::CommandRecorder
3588
3852
  def invert_remove_belongs_to(args, &block); end
3589
3853
  def record(*command, &block); end
3590
3854
  def remove_belongs_to(*args, &block); end
3855
+ def remove_check_constraint(*args, &block); end
3591
3856
  def remove_column(*args, &block); end
3592
3857
  def remove_columns(*args, &block); end
3593
3858
  def remove_foreign_key(*args, &block); end
@@ -3600,17 +3865,17 @@ class ActiveRecord::Migration::CommandRecorder
3600
3865
  def replay(migration); end
3601
3866
  def revert; end
3602
3867
  def reverting; end
3603
- def reverting=(_); end
3868
+ def reverting=(_arg0); end
3604
3869
  def transaction(*args, &block); end
3605
3870
 
3606
3871
  private
3607
3872
 
3608
- def invert_add_index(args); end
3609
3873
  def invert_change_column_comment(args); end
3610
3874
  def invert_change_column_default(args); end
3611
3875
  def invert_change_column_null(args); end
3612
3876
  def invert_change_table_comment(args); end
3613
3877
  def invert_drop_table(args, &block); end
3878
+ def invert_remove_check_constraint(args); end
3614
3879
  def invert_remove_column(args); end
3615
3880
  def invert_remove_columns(args); end
3616
3881
  def invert_remove_foreign_key(args); end
@@ -3626,8 +3891,10 @@ end
3626
3891
  ActiveRecord::Migration::CommandRecorder::ReversibleAndIrreversibleMethods = T.let(T.unsafe(nil), Array)
3627
3892
 
3628
3893
  module ActiveRecord::Migration::CommandRecorder::StraightReversions
3894
+ def invert_add_check_constraint(args, &block); end
3629
3895
  def invert_add_column(args, &block); end
3630
3896
  def invert_add_foreign_key(args, &block); end
3897
+ def invert_add_index(args, &block); end
3631
3898
  def invert_add_reference(args, &block); end
3632
3899
  def invert_add_timestamps(args, &block); end
3633
3900
  def invert_create_join_table(args, &block); end
@@ -3637,8 +3904,10 @@ module ActiveRecord::Migration::CommandRecorder::StraightReversions
3637
3904
  def invert_drop_table(args, &block); end
3638
3905
  def invert_enable_extension(args, &block); end
3639
3906
  def invert_execute_block(args, &block); end
3907
+ def invert_remove_check_constraint(args, &block); end
3640
3908
  def invert_remove_column(args, &block); end
3641
3909
  def invert_remove_foreign_key(args, &block); end
3910
+ def invert_remove_index(args, &block); end
3642
3911
  def invert_remove_reference(args, &block); end
3643
3912
  def invert_remove_timestamps(args, &block); end
3644
3913
  end
@@ -3653,18 +3922,18 @@ class ActiveRecord::Migration::Compatibility::V4_2 < ::ActiveRecord::Migration::
3653
3922
  def add_belongs_to(table_name, ref_name, **options); end
3654
3923
  def add_reference(table_name, ref_name, **options); end
3655
3924
  def add_timestamps(table_name, **options); end
3656
- def index_exists?(table_name, column_name, options = T.unsafe(nil)); end
3657
- def remove_index(table_name, options = T.unsafe(nil)); end
3925
+ def index_exists?(table_name, column_name, **options); end
3926
+ def remove_index(table_name, column_name = T.unsafe(nil), **options); end
3658
3927
 
3659
3928
  private
3660
3929
 
3661
3930
  def compatible_table_definition(t); end
3662
- def index_name_for_remove(table_name, options = T.unsafe(nil)); end
3931
+ def index_name_for_remove(table_name, column_name, options); end
3663
3932
  end
3664
3933
 
3665
3934
  module ActiveRecord::Migration::Compatibility::V4_2::TableDefinition
3666
- def belongs_to(*_, **options); end
3667
- def references(*_, **options); end
3935
+ def belongs_to(*_arg0, **options); end
3936
+ def references(*_arg0, **options); end
3668
3937
  def timestamps(**options); end
3669
3938
  end
3670
3939
 
@@ -3687,7 +3956,7 @@ module ActiveRecord::Migration::Compatibility::V5_0::TableDefinition
3687
3956
  end
3688
3957
 
3689
3958
  class ActiveRecord::Migration::Compatibility::V5_1 < ::ActiveRecord::Migration::Compatibility::V5_2
3690
- def change_column(table_name, column_name, type, options = T.unsafe(nil)); end
3959
+ def change_column(table_name, column_name, type, **options); end
3691
3960
  def create_table(table_name, **options); end
3692
3961
  end
3693
3962
 
@@ -3713,10 +3982,31 @@ module ActiveRecord::Migration::Compatibility::V5_2::TableDefinition
3713
3982
  def timestamps(**options); end
3714
3983
  end
3715
3984
 
3716
- class ActiveRecord::Migration::Compatibility::V6_0 < ::ActiveRecord::Migration::Current
3985
+ class ActiveRecord::Migration::Compatibility::V6_0 < ::ActiveRecord::Migration::Compatibility::V6_1
3986
+ def add_belongs_to(table_name, ref_name, **options); end
3987
+ def add_reference(table_name, ref_name, **options); end
3988
+ def change_table(table_name, **options); end
3989
+ def create_join_table(table_1, table_2, **options); end
3990
+ def create_table(table_name, **options); end
3991
+
3992
+ private
3993
+
3994
+ def compatible_table_definition(t); end
3995
+ end
3996
+
3997
+ class ActiveRecord::Migration::Compatibility::V6_0::ReferenceDefinition < ::ActiveRecord::ConnectionAdapters::ReferenceDefinition
3998
+ def index_options(table_name); end
3999
+ end
4000
+
4001
+ module ActiveRecord::Migration::Compatibility::V6_0::TableDefinition
4002
+ def belongs_to(*args, **options); end
4003
+ def references(*args, **options); end
4004
+ end
4005
+
4006
+ class ActiveRecord::Migration::Compatibility::V6_1 < ::ActiveRecord::Migration::Current
3717
4007
  end
3718
4008
 
3719
- ActiveRecord::Migration::Compatibility::V6_1 = ActiveRecord::Migration::Current
4009
+ ActiveRecord::Migration::Compatibility::V7_0 = ActiveRecord::Migration::Current
3720
4010
 
3721
4011
  class ActiveRecord::Migration::Current < ::ActiveRecord::Migration
3722
4012
  end
@@ -3738,10 +4028,10 @@ class ActiveRecord::Migration::ReversibleBlockHelper < ::Struct
3738
4028
  def up; end
3739
4029
 
3740
4030
  class << self
3741
- def [](*_); end
4031
+ def [](*_arg0); end
3742
4032
  def inspect; end
3743
4033
  def members; end
3744
- def new(*_); end
4034
+ def new(*_arg0); end
3745
4035
  end
3746
4036
  end
3747
4037
 
@@ -3779,11 +4069,12 @@ class ActiveRecord::Migrator
3779
4069
  def use_transaction?(migration); end
3780
4070
  def validate(migrations); end
3781
4071
  def with_advisory_lock; end
4072
+ def with_advisory_lock_connection; end
3782
4073
 
3783
4074
  class << self
3784
4075
  def current_version; end
3785
4076
  def migrations_paths; end
3786
- def migrations_paths=(_); end
4077
+ def migrations_paths=(_arg0); end
3787
4078
  end
3788
4079
  end
3789
4080
 
@@ -3806,6 +4097,7 @@ module ActiveRecord::ModelSchema::ClassMethods
3806
4097
  def attribute_types; end
3807
4098
  def attributes_builder; end
3808
4099
  def column_defaults; end
4100
+ def column_for_attribute(name); end
3809
4101
  def column_names; end
3810
4102
  def columns; end
3811
4103
  def columns_hash; end
@@ -3839,6 +4131,7 @@ module ActiveRecord::ModelSchema::ClassMethods
3839
4131
 
3840
4132
  private
3841
4133
 
4134
+ def _convert_type_from_options(type); end
3842
4135
  def compute_table_name; end
3843
4136
  def inherited(child_class); end
3844
4137
  def load_schema; end
@@ -3846,6 +4139,7 @@ module ActiveRecord::ModelSchema::ClassMethods
3846
4139
  def reload_schema_from_cache; end
3847
4140
  def schema_loaded?; end
3848
4141
  def undecorated_table_name(class_name = T.unsafe(nil)); end
4142
+ def warn_if_deprecated_type(column); end
3849
4143
  end
3850
4144
 
3851
4145
  class ActiveRecord::MultiparameterAssignmentErrors < ::ActiveRecord::ActiveRecordError
@@ -3899,8 +4193,8 @@ module ActiveRecord::NoTouching
3899
4193
  mixes_in_class_methods(::ActiveRecord::NoTouching::ClassMethods)
3900
4194
 
3901
4195
  def no_touching?; end
3902
- def touch(*_, **_); end
3903
- def touch_later(*_); end
4196
+ def touch(*_arg0, **_arg1); end
4197
+ def touch_later(*_arg0); end
3904
4198
 
3905
4199
  class << self
3906
4200
  def applied_to?(klass); end
@@ -3966,8 +4260,6 @@ module ActiveRecord::Persistence
3966
4260
  def update(attributes); end
3967
4261
  def update!(attributes); end
3968
4262
  def update_attribute(name, value); end
3969
- def update_attributes(*args, &block); end
3970
- def update_attributes!(*args, &block); end
3971
4263
  def update_column(name, value); end
3972
4264
  def update_columns(attributes); end
3973
4265
 
@@ -3975,14 +4267,17 @@ module ActiveRecord::Persistence
3975
4267
 
3976
4268
  def _create_record(attribute_names = T.unsafe(nil)); end
3977
4269
  def _delete_row; end
4270
+ def _find_record(options); end
4271
+ def _primary_key_constraints_hash; end
3978
4272
  def _raise_readonly_record_error; end
3979
4273
  def _raise_record_not_destroyed; end
3980
4274
  def _raise_record_not_touched_error; end
3981
4275
  def _touch_row(attribute_names, time); end
3982
4276
  def _update_record(attribute_names = T.unsafe(nil)); end
3983
4277
  def _update_row(attribute_names, attempted_action = T.unsafe(nil)); end
4278
+ def apply_scoping?(options); end
3984
4279
  def belongs_to_touch_method; end
3985
- def create_or_update(**_, &block); end
4280
+ def create_or_update(**_arg0, &block); end
3986
4281
  def destroy_associations; end
3987
4282
  def destroy_row; end
3988
4283
  def verify_readonly_attribute(name); end
@@ -4007,7 +4302,6 @@ module ActiveRecord::Persistence::ClassMethods
4007
4302
 
4008
4303
  private
4009
4304
 
4010
- def _substitute_values(values); end
4011
4305
  def discriminate_class_for_record(record); end
4012
4306
  def instantiate_instance_of(klass, attributes, column_types = T.unsafe(nil), &block); end
4013
4307
  end
@@ -4015,19 +4309,21 @@ end
4015
4309
  class ActiveRecord::PredicateBuilder
4016
4310
  def initialize(table); end
4017
4311
 
4018
- def build(attribute, value); end
4312
+ def [](attr_name, value, operator = T.unsafe(nil)); end
4313
+ def build(attribute, value, operator = T.unsafe(nil)); end
4019
4314
  def build_bind_attribute(column_name, value); end
4020
- def build_from_hash(attributes); end
4315
+ def build_from_hash(attributes, &block); end
4021
4316
  def register_handler(klass, handler); end
4022
- def resolve_arel_attribute(table_name, column_name); end
4317
+ def resolve_arel_attribute(table_name, column_name, &block); end
4023
4318
 
4024
4319
  protected
4025
4320
 
4026
- def expand_from_hash(attributes); end
4321
+ def expand_from_hash(attributes, &block); end
4027
4322
 
4028
4323
  private
4029
4324
 
4030
4325
  def convert_dot_notation_to_hash(attributes); end
4326
+ def grouping_queries(queries); end
4031
4327
  def handler_for(object); end
4032
4328
  def table; end
4033
4329
 
@@ -4066,16 +4362,6 @@ class ActiveRecord::PredicateBuilder::AssociationQueryValue
4066
4362
  def value; end
4067
4363
  end
4068
4364
 
4069
- class ActiveRecord::PredicateBuilder::BaseHandler
4070
- def initialize(predicate_builder); end
4071
-
4072
- def call(attribute, value); end
4073
-
4074
- private
4075
-
4076
- def predicate_builder; end
4077
- end
4078
-
4079
4365
  class ActiveRecord::PredicateBuilder::BasicObjectHandler
4080
4366
  def initialize(predicate_builder); end
4081
4367
 
@@ -4119,10 +4405,10 @@ class ActiveRecord::PredicateBuilder::RangeHandler::RangeWithBinds < ::Struct
4119
4405
  def exclude_end?; end
4120
4406
 
4121
4407
  class << self
4122
- def [](*_); end
4408
+ def [](*_arg0); end
4123
4409
  def inspect; end
4124
4410
  def members; end
4125
- def new(*_); end
4411
+ def new(*_arg0); end
4126
4412
  end
4127
4413
  end
4128
4414
 
@@ -4157,9 +4443,10 @@ end
4157
4443
 
4158
4444
  module ActiveRecord::QueryMethods
4159
4445
  include(::ActiveModel::ForbiddenAttributesProtection)
4160
- extend(::ActiveSupport::Concern)
4161
4446
 
4162
4447
  def _select!(*fields); end
4448
+ def and(other); end
4449
+ def and!(other); end
4163
4450
  def annotate(*args); end
4164
4451
  def annotate!(*args); end
4165
4452
  def annotate_values; end
@@ -4178,6 +4465,8 @@ module ActiveRecord::QueryMethods
4178
4465
  def eager_load!(*args); end
4179
4466
  def eager_load_values; end
4180
4467
  def eager_load_values=(value); end
4468
+ def excluding(*records); end
4469
+ def excluding!(records); end
4181
4470
  def extending(*modules, &block); end
4182
4471
  def extending!(*modules, &block); end
4183
4472
  def extending_values; end
@@ -4200,6 +4489,8 @@ module ActiveRecord::QueryMethods
4200
4489
  def includes!(*args); end
4201
4490
  def includes_values; end
4202
4491
  def includes_values=(value); end
4492
+ def invert_where; end
4493
+ def invert_where!; end
4203
4494
  def joins(*args); end
4204
4495
  def joins!(*args); end
4205
4496
  def joins_values; end
@@ -4267,19 +4558,22 @@ module ActiveRecord::QueryMethods
4267
4558
  def strict_loading!(value = T.unsafe(nil)); end
4268
4559
  def strict_loading_value; end
4269
4560
  def strict_loading_value=(value); end
4561
+ def uniq!(name); end
4270
4562
  def unscope(*args); end
4271
4563
  def unscope!(*args); end
4272
4564
  def unscope_values; end
4273
4565
  def unscope_values=(value); end
4274
- def where(opts = T.unsafe(nil), *rest); end
4566
+ def where(*args); end
4275
4567
  def where!(opts, *rest); end
4276
4568
  def where_clause; end
4277
4569
  def where_clause=(value); end
4570
+ def without(*records); end
4278
4571
 
4279
4572
  protected
4280
4573
 
4574
+ def build_having_clause(opts, rest = T.unsafe(nil)); end
4281
4575
  def build_subquery(subquery_alias, select_value); end
4282
- def build_where_clause(opts, *rest); end
4576
+ def build_where_clause(opts, rest = T.unsafe(nil)); end
4283
4577
 
4284
4578
  private
4285
4579
 
@@ -4289,141 +4583,143 @@ module ActiveRecord::QueryMethods
4289
4583
  def build_arel(aliases); end
4290
4584
  def build_cast_value(name, value); end
4291
4585
  def build_from; end
4292
- def build_join_query(manager, buckets, join_type, aliases); end
4293
- def build_joins(manager, joins, aliases); end
4294
- def build_left_outer_joins(manager, outer_joins, aliases); end
4586
+ def build_join_buckets; end
4587
+ def build_join_dependencies; end
4588
+ def build_joins(join_sources, aliases = T.unsafe(nil)); end
4295
4589
  def build_order(arel); end
4296
4590
  def build_select(arel); end
4297
- def check_if_method_has_arguments!(method_name, args); end
4591
+ def check_if_method_has_arguments!(method_name, args, message = T.unsafe(nil)); end
4298
4592
  def column_references(order_args); end
4299
4593
  def does_not_support_reverse?(order); end
4300
- def having_clause_factory; end
4594
+ def each_join_dependencies(join_dependencies = T.unsafe(nil)); end
4595
+ def lookup_table_klass_from_join_dependencies(table_name); end
4301
4596
  def order_column(field); end
4302
4597
  def preprocess_order_args(order_args); end
4303
4598
  def resolve_arel_attributes(attrs); end
4304
4599
  def reverse_sql_order(order_query); end
4305
4600
  def sanitize_order_arguments(order_args); end
4306
- def select_association_list(associations); end
4307
- def structurally_incompatible_values_for_or(other); end
4601
+ def select_association_list(associations, stashed_joins = T.unsafe(nil)); end
4602
+ def structurally_incompatible_values_for(other); end
4308
4603
  def table_name_matches?(from); end
4309
- def valid_association_list(associations); end
4310
4604
  def validate_order_args(args); end
4311
- def where_clause_factory; end
4312
4605
  end
4313
4606
 
4314
4607
  ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY = T.let(T.unsafe(nil), Array)
4315
4608
 
4316
4609
  ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH = T.let(T.unsafe(nil), Hash)
4317
4610
 
4318
- ActiveRecord::QueryMethods::STRUCTURAL_OR_METHODS = T.let(T.unsafe(nil), Array)
4611
+ ActiveRecord::QueryMethods::STRUCTURAL_VALUE_METHODS = T.let(T.unsafe(nil), Array)
4319
4612
 
4320
4613
  ActiveRecord::QueryMethods::VALID_DIRECTIONS = T.let(T.unsafe(nil), Set)
4321
4614
 
4322
4615
  ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES = T.let(T.unsafe(nil), Set)
4323
4616
 
4324
4617
  class ActiveRecord::QueryMethods::WhereChain
4325
- include(::ActiveModel::ForbiddenAttributesProtection)
4326
-
4327
4618
  def initialize(scope); end
4328
4619
 
4329
- def missing(*args); end
4620
+ def associated(*associations); end
4621
+ def missing(*associations); end
4330
4622
  def not(opts, *rest); end
4331
-
4332
- private
4333
-
4334
- def not_behaves_as_nor?(opts); end
4335
4623
  end
4336
4624
 
4337
4625
  module ActiveRecord::Querying
4338
- def annotate(*args, &block); end
4339
- def any?(*args, &block); end
4340
- def average(*args, &block); end
4341
- def calculate(*args, &block); end
4342
- def count(*args, &block); end
4626
+ def _load_from_sql(result_set, &block); end
4627
+ def _query_by_sql(sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil)); end
4628
+ def and(*_arg0, &_arg1); end
4629
+ def annotate(*_arg0, &_arg1); end
4630
+ def any?(*_arg0, &_arg1); end
4631
+ def average(*_arg0, &_arg1); end
4632
+ def calculate(*_arg0, &_arg1); end
4633
+ def count(*_arg0, &_arg1); end
4343
4634
  def count_by_sql(sql); end
4344
- def create_or_find_by(*args, &block); end
4345
- def create_or_find_by!(*args, &block); end
4346
- def create_with(*args, &block); end
4347
- def delete_all(*args, &block); end
4348
- def delete_by(*args, &block); end
4349
- def destroy_all(*args, &block); end
4350
- def destroy_by(*args, &block); end
4351
- def distinct(*args, &block); end
4352
- def eager_load(*args, &block); end
4353
- def except(*args, &block); end
4354
- def exists?(*args, &block); end
4355
- def extending(*args, &block); end
4356
- def extract_associated(*args, &block); end
4357
- def fifth(*args, &block); end
4358
- def fifth!(*args, &block); end
4359
- def find(*args, &block); end
4360
- def find_by(*args, &block); end
4361
- def find_by!(*args, &block); end
4635
+ def create_or_find_by(*_arg0, &_arg1); end
4636
+ def create_or_find_by!(*_arg0, &_arg1); end
4637
+ def create_with(*_arg0, &_arg1); end
4638
+ def delete_all(*_arg0, &_arg1); end
4639
+ def delete_by(*_arg0, &_arg1); end
4640
+ def destroy_all(*_arg0, &_arg1); end
4641
+ def destroy_by(*_arg0, &_arg1); end
4642
+ def distinct(*_arg0, &_arg1); end
4643
+ def eager_load(*_arg0, &_arg1); end
4644
+ def except(*_arg0, &_arg1); end
4645
+ def excluding(*_arg0, &_arg1); end
4646
+ def exists?(*_arg0, &_arg1); end
4647
+ def extending(*_arg0, &_arg1); end
4648
+ def extract_associated(*_arg0, &_arg1); end
4649
+ def fifth(*_arg0, &_arg1); end
4650
+ def fifth!(*_arg0, &_arg1); end
4651
+ def find(*_arg0, &_arg1); end
4652
+ def find_by(*_arg0, &_arg1); end
4653
+ def find_by!(*_arg0, &_arg1); end
4362
4654
  def find_by_sql(sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), &block); end
4363
- def find_each(*args, &block); end
4364
- def find_in_batches(*args, &block); end
4365
- def find_or_create_by(*args, &block); end
4366
- def find_or_create_by!(*args, &block); end
4367
- def find_or_initialize_by(*args, &block); end
4368
- def first(*args, &block); end
4369
- def first!(*args, &block); end
4370
- def first_or_create(*args, &block); end
4371
- def first_or_create!(*args, &block); end
4372
- def first_or_initialize(*args, &block); end
4373
- def forty_two(*args, &block); end
4374
- def forty_two!(*args, &block); end
4375
- def fourth(*args, &block); end
4376
- def fourth!(*args, &block); end
4377
- def from(*args, &block); end
4378
- def group(*args, &block); end
4379
- def having(*args, &block); end
4380
- def ids(*args, &block); end
4381
- def in_batches(*args, &block); end
4382
- def includes(*args, &block); end
4383
- def joins(*args, &block); end
4384
- def last(*args, &block); end
4385
- def last!(*args, &block); end
4386
- def left_joins(*args, &block); end
4387
- def left_outer_joins(*args, &block); end
4388
- def limit(*args, &block); end
4389
- def lock(*args, &block); end
4390
- def many?(*args, &block); end
4391
- def maximum(*args, &block); end
4392
- def merge(*args, &block); end
4393
- def minimum(*args, &block); end
4394
- def none(*args, &block); end
4395
- def none?(*args, &block); end
4396
- def offset(*args, &block); end
4397
- def one?(*args, &block); end
4398
- def only(*args, &block); end
4399
- def optimizer_hints(*args, &block); end
4400
- def or(*args, &block); end
4401
- def order(*args, &block); end
4402
- def pick(*args, &block); end
4403
- def pluck(*args, &block); end
4404
- def preload(*args, &block); end
4405
- def readonly(*args, &block); end
4406
- def references(*args, &block); end
4407
- def reorder(*args, &block); end
4408
- def reselect(*args, &block); end
4409
- def rewhere(*args, &block); end
4410
- def second(*args, &block); end
4411
- def second!(*args, &block); end
4412
- def second_to_last(*args, &block); end
4413
- def second_to_last!(*args, &block); end
4414
- def select(*args, &block); end
4415
- def strict_loading(*args, &block); end
4416
- def sum(*args, &block); end
4417
- def take(*args, &block); end
4418
- def take!(*args, &block); end
4419
- def third(*args, &block); end
4420
- def third!(*args, &block); end
4421
- def third_to_last(*args, &block); end
4422
- def third_to_last!(*args, &block); end
4423
- def touch_all(*args, &block); end
4424
- def unscope(*args, &block); end
4425
- def update_all(*args, &block); end
4426
- def where(*args, &block); end
4655
+ def find_each(*_arg0, &_arg1); end
4656
+ def find_in_batches(*_arg0, &_arg1); end
4657
+ def find_or_create_by(*_arg0, &_arg1); end
4658
+ def find_or_create_by!(*_arg0, &_arg1); end
4659
+ def find_or_initialize_by(*_arg0, &_arg1); end
4660
+ def find_sole_by(*_arg0, &_arg1); end
4661
+ def first(*_arg0, &_arg1); end
4662
+ def first!(*_arg0, &_arg1); end
4663
+ def first_or_create(*_arg0, &_arg1); end
4664
+ def first_or_create!(*_arg0, &_arg1); end
4665
+ def first_or_initialize(*_arg0, &_arg1); end
4666
+ def forty_two(*_arg0, &_arg1); end
4667
+ def forty_two!(*_arg0, &_arg1); end
4668
+ def fourth(*_arg0, &_arg1); end
4669
+ def fourth!(*_arg0, &_arg1); end
4670
+ def from(*_arg0, &_arg1); end
4671
+ def group(*_arg0, &_arg1); end
4672
+ def having(*_arg0, &_arg1); end
4673
+ def ids(*_arg0, &_arg1); end
4674
+ def in_batches(*_arg0, &_arg1); end
4675
+ def includes(*_arg0, &_arg1); end
4676
+ def invert_where(*_arg0, &_arg1); end
4677
+ def joins(*_arg0, &_arg1); end
4678
+ def last(*_arg0, &_arg1); end
4679
+ def last!(*_arg0, &_arg1); end
4680
+ def left_joins(*_arg0, &_arg1); end
4681
+ def left_outer_joins(*_arg0, &_arg1); end
4682
+ def limit(*_arg0, &_arg1); end
4683
+ def lock(*_arg0, &_arg1); end
4684
+ def many?(*_arg0, &_arg1); end
4685
+ def maximum(*_arg0, &_arg1); end
4686
+ def merge(*_arg0, &_arg1); end
4687
+ def minimum(*_arg0, &_arg1); end
4688
+ def none(*_arg0, &_arg1); end
4689
+ def none?(*_arg0, &_arg1); end
4690
+ def offset(*_arg0, &_arg1); end
4691
+ def one?(*_arg0, &_arg1); end
4692
+ def only(*_arg0, &_arg1); end
4693
+ def optimizer_hints(*_arg0, &_arg1); end
4694
+ def or(*_arg0, &_arg1); end
4695
+ def order(*_arg0, &_arg1); end
4696
+ def pick(*_arg0, &_arg1); end
4697
+ def pluck(*_arg0, &_arg1); end
4698
+ def preload(*_arg0, &_arg1); end
4699
+ def readonly(*_arg0, &_arg1); end
4700
+ def references(*_arg0, &_arg1); end
4701
+ def reorder(*_arg0, &_arg1); end
4702
+ def reselect(*_arg0, &_arg1); end
4703
+ def rewhere(*_arg0, &_arg1); end
4704
+ def second(*_arg0, &_arg1); end
4705
+ def second!(*_arg0, &_arg1); end
4706
+ def second_to_last(*_arg0, &_arg1); end
4707
+ def second_to_last!(*_arg0, &_arg1); end
4708
+ def select(*_arg0, &_arg1); end
4709
+ def sole(*_arg0, &_arg1); end
4710
+ def strict_loading(*_arg0, &_arg1); end
4711
+ def sum(*_arg0, &_arg1); end
4712
+ def take(*_arg0, &_arg1); end
4713
+ def take!(*_arg0, &_arg1); end
4714
+ def third(*_arg0, &_arg1); end
4715
+ def third!(*_arg0, &_arg1); end
4716
+ def third_to_last(*_arg0, &_arg1); end
4717
+ def third_to_last!(*_arg0, &_arg1); end
4718
+ def touch_all(*_arg0, &_arg1); end
4719
+ def unscope(*_arg0, &_arg1); end
4720
+ def update_all(*_arg0, &_arg1); end
4721
+ def where(*_arg0, &_arg1); end
4722
+ def without(*_arg0, &_arg1); end
4427
4723
  end
4428
4724
 
4429
4725
  ActiveRecord::Querying::QUERYING_METHODS = T.let(T.unsafe(nil), Array)
@@ -4500,24 +4796,20 @@ end
4500
4796
  class ActiveRecord::Reflection::AbstractReflection
4501
4797
  def alias_candidate(name); end
4502
4798
  def build_association(attributes, &block); end
4503
- def build_scope(table, predicate_builder = T.unsafe(nil)); end
4799
+ def build_scope(table, predicate_builder = T.unsafe(nil), klass = T.unsafe(nil)); end
4504
4800
  def chain; end
4505
4801
  def check_validity_of_inverse!; end
4506
4802
  def class_name; end
4507
4803
  def constraints; end
4508
4804
  def counter_cache_column; end
4509
4805
  def counter_must_be_updated_by_has_many?; end
4510
- def get_join_keys(association_klass); end
4511
4806
  def has_cached_counter?; end
4512
4807
  def inverse_of; end
4513
4808
  def inverse_updates_counter_cache?; end
4514
4809
  def inverse_updates_counter_in_memory?; end
4515
4810
  def inverse_which_updates_counter_cache; end
4516
- def join_foreign_key; end
4517
- def join_keys; end
4518
- def join_primary_key(*_); end
4519
4811
  def join_scope(table, foreign_table, foreign_klass); end
4520
- def join_scopes(table, predicate_builder); end
4812
+ def join_scopes(table, predicate_builder, klass = T.unsafe(nil)); end
4521
4813
  def klass_join_scope(table, predicate_builder); end
4522
4814
  def scopes; end
4523
4815
  def strict_loading?; end
@@ -4530,24 +4822,11 @@ class ActiveRecord::Reflection::AbstractReflection
4530
4822
 
4531
4823
  private
4532
4824
 
4825
+ def ensure_option_not_given_as_class!(option_name); end
4533
4826
  def predicate_builder(table); end
4534
4827
  def primary_key(klass); end
4535
4828
  end
4536
4829
 
4537
- class ActiveRecord::Reflection::AbstractReflection::JoinKeys < ::Struct
4538
- def foreign_key; end
4539
- def foreign_key=(_); end
4540
- def key; end
4541
- def key=(_); end
4542
-
4543
- class << self
4544
- def [](*_); end
4545
- def inspect; end
4546
- def members; end
4547
- def new(*_); end
4548
- end
4549
- end
4550
-
4551
4830
  class ActiveRecord::Reflection::AggregateReflection < ::ActiveRecord::Reflection::MacroReflection
4552
4831
  def mapping; end
4553
4832
  end
@@ -4562,7 +4841,7 @@ class ActiveRecord::Reflection::AssociationReflection < ::ActiveRecord::Reflecti
4562
4841
  def association_class; end
4563
4842
  def association_foreign_key; end
4564
4843
  def association_primary_key(klass = T.unsafe(nil)); end
4565
- def association_scope_cache(conn, owner, &block); end
4844
+ def association_scope_cache(klass, owner, &block); end
4566
4845
  def belongs_to?; end
4567
4846
  def check_eager_loadable!; end
4568
4847
  def check_preloadable!; end
@@ -4571,19 +4850,20 @@ class ActiveRecord::Reflection::AssociationReflection < ::ActiveRecord::Reflecti
4571
4850
  def collect_join_chain; end
4572
4851
  def collection?; end
4573
4852
  def compute_class(name); end
4574
- def constructable?; end
4575
4853
  def extensions; end
4576
4854
  def foreign_key; end
4577
4855
  def foreign_type; end
4578
4856
  def has_inverse?; end
4579
4857
  def has_one?; end
4580
4858
  def has_scope?; end
4859
+ def join_foreign_key; end
4581
4860
  def join_id_for(owner); end
4861
+ def join_primary_key(klass = T.unsafe(nil)); end
4582
4862
  def join_table; end
4583
4863
  def macro; end
4584
4864
  def nested?; end
4585
4865
  def parent_reflection; end
4586
- def parent_reflection=(_); end
4866
+ def parent_reflection=(_arg0); end
4587
4867
  def polymorphic?; end
4588
4868
  def polymorphic_inverse_of(associated_class); end
4589
4869
  def source_reflection; end
@@ -4594,7 +4874,6 @@ class ActiveRecord::Reflection::AssociationReflection < ::ActiveRecord::Reflecti
4594
4874
  private
4595
4875
 
4596
4876
  def automatic_inverse_of; end
4597
- def calculate_constructable(macro, options); end
4598
4877
  def can_find_inverse_of_automatically?(reflection); end
4599
4878
  def derive_class_name; end
4600
4879
  def derive_foreign_key; end
@@ -4603,20 +4882,17 @@ class ActiveRecord::Reflection::AssociationReflection < ::ActiveRecord::Reflecti
4603
4882
  def valid_inverse_reflection?(reflection); end
4604
4883
  end
4605
4884
 
4606
- ActiveRecord::Reflection::AssociationReflection::INVALID_AUTOMATIC_INVERSE_OPTIONS = T.let(T.unsafe(nil), Array)
4607
-
4608
- ActiveRecord::Reflection::AssociationReflection::VALID_AUTOMATIC_INVERSE_MACROS = T.let(T.unsafe(nil), Array)
4609
-
4610
4885
  class ActiveRecord::Reflection::BelongsToReflection < ::ActiveRecord::Reflection::AssociationReflection
4611
4886
  def association_class; end
4887
+ def association_primary_key(klass = T.unsafe(nil)); end
4612
4888
  def belongs_to?; end
4613
4889
  def join_foreign_key; end
4890
+ def join_foreign_type; end
4614
4891
  def join_primary_key(klass = T.unsafe(nil)); end
4615
4892
  def macro; end
4616
4893
 
4617
4894
  private
4618
4895
 
4619
- def calculate_constructable(macro, options); end
4620
4896
  def can_find_inverse_of_automatically?(_); end
4621
4897
  end
4622
4898
 
@@ -4638,7 +4914,6 @@ end
4638
4914
 
4639
4915
  class ActiveRecord::Reflection::HasManyReflection < ::ActiveRecord::Reflection::AssociationReflection
4640
4916
  def association_class; end
4641
- def association_primary_key(klass = T.unsafe(nil)); end
4642
4917
  def collection?; end
4643
4918
  def macro; end
4644
4919
  end
@@ -4647,10 +4922,6 @@ class ActiveRecord::Reflection::HasOneReflection < ::ActiveRecord::Reflection::A
4647
4922
  def association_class; end
4648
4923
  def has_one?; end
4649
4924
  def macro; end
4650
-
4651
- private
4652
-
4653
- def calculate_constructable(macro, options); end
4654
4925
  end
4655
4926
 
4656
4927
  class ActiveRecord::Reflection::MacroReflection < ::ActiveRecord::Reflection::AbstractReflection
@@ -4676,13 +4947,15 @@ class ActiveRecord::Reflection::PolymorphicReflection < ::ActiveRecord::Reflecti
4676
4947
  def initialize(reflection, previous_reflection); end
4677
4948
 
4678
4949
  def constraints; end
4679
- def get_join_keys(*args, &block); end
4680
- def join_scopes(table, predicate_builder); end
4681
- def klass(*args, &block); end
4682
- def plural_name(*args, &block); end
4683
- def scope(*args, &block); end
4684
- def scope_for(*args, &block); end
4685
- def type(*args, &block); end
4950
+ def join_foreign_key(*_arg0, &_arg1); end
4951
+ def join_primary_key(*_arg0, &_arg1); end
4952
+ def join_scopes(table, predicate_builder, klass = T.unsafe(nil)); end
4953
+ def klass(*_arg0, &_arg1); end
4954
+ def name(*_arg0, &_arg1); end
4955
+ def plural_name(*_arg0, &_arg1); end
4956
+ def scope(*_arg0, &_arg1); end
4957
+ def scope_for(*_arg0, &_arg1); end
4958
+ def type(*_arg0, &_arg1); end
4686
4959
 
4687
4960
  private
4688
4961
 
@@ -4694,58 +4967,59 @@ class ActiveRecord::Reflection::RuntimeReflection < ::ActiveRecord::Reflection::
4694
4967
 
4695
4968
  def aliased_table; end
4696
4969
  def all_includes; end
4697
- def constraints(*args, &block); end
4698
- def get_join_keys(*args, &block); end
4970
+ def constraints(*_arg0, &_arg1); end
4971
+ def join_foreign_key(*_arg0, &_arg1); end
4972
+ def join_primary_key(klass = T.unsafe(nil)); end
4699
4973
  def klass; end
4700
- def scope(*args, &block); end
4701
- def type(*args, &block); end
4974
+ def scope(*_arg0, &_arg1); end
4975
+ def type(*_arg0, &_arg1); end
4702
4976
  end
4703
4977
 
4704
4978
  class ActiveRecord::Reflection::ThroughReflection < ::ActiveRecord::Reflection::AbstractReflection
4705
4979
  def initialize(delegate_reflection); end
4706
4980
 
4707
- def active_record(*args, &block); end
4708
- def active_record_primary_key(*args, &block); end
4981
+ def active_record(*_arg0, &_arg1); end
4982
+ def active_record_primary_key(*_arg0, &_arg1); end
4709
4983
  def add_as_polymorphic_through(reflection, seed); end
4710
4984
  def add_as_source(seed); end
4711
4985
  def add_as_through(seed); end
4712
- def association_class(*args, &block); end
4713
- def association_foreign_key(*args, &block); end
4986
+ def association_class(*_arg0, &_arg1); end
4987
+ def association_foreign_key(*_arg0, &_arg1); end
4714
4988
  def association_primary_key(klass = T.unsafe(nil)); end
4715
- def association_scope_cache(*args, &block); end
4989
+ def association_scope_cache(*_arg0, &_arg1); end
4716
4990
  def autosave=(arg); end
4717
- def belongs_to?(*args, &block); end
4718
- def check_eager_loadable!(*args, &block); end
4719
- def check_preloadable!(*args, &block); end
4991
+ def belongs_to?(*_arg0, &_arg1); end
4992
+ def check_eager_loadable!(*_arg0, &_arg1); end
4993
+ def check_preloadable!(*_arg0, &_arg1); end
4720
4994
  def check_validity!; end
4721
4995
  def clear_association_scope_cache; end
4722
4996
  def collect_join_chain; end
4723
- def collection?(*args, &block); end
4724
- def compute_class(*args, &block); end
4997
+ def collection?(*_arg0, &_arg1); end
4998
+ def compute_class(*_arg0, &_arg1); end
4725
4999
  def constraints; end
4726
- def constructable?(*args, &block); end
4727
- def extensions(*args, &block); end
4728
- def foreign_key(*args, &block); end
4729
- def foreign_type(*args, &block); end
4730
- def get_join_keys(*args, &block); end
4731
- def has_inverse?(*args, &block); end
4732
- def has_one?(*args, &block); end
5000
+ def extensions(*_arg0, &_arg1); end
5001
+ def foreign_key(*_arg0, &_arg1); end
5002
+ def foreign_type(*_arg0, &_arg1); end
5003
+ def has_inverse?(*_arg0, &_arg1); end
5004
+ def has_one?(*_arg0, &_arg1); end
4733
5005
  def has_scope?; end
4734
- def join_id_for(*args, &block); end
4735
- def join_scopes(table, predicate_builder); end
4736
- def join_table(*args, &block); end
5006
+ def join_foreign_key(*_arg0, &_arg1); end
5007
+ def join_id_for(*_arg0, &_arg1); end
5008
+ def join_primary_key(klass = T.unsafe(nil)); end
5009
+ def join_scopes(table, predicate_builder, klass = T.unsafe(nil)); end
5010
+ def join_table(*_arg0, &_arg1); end
4737
5011
  def klass; end
4738
- def macro(*args, &block); end
4739
- def name(*args, &block); end
5012
+ def macro(*_arg0, &_arg1); end
5013
+ def name(*_arg0, &_arg1); end
4740
5014
  def nested?; end
4741
- def options(*args, &block); end
4742
- def parent_reflection(*args, &block); end
5015
+ def options(*_arg0, &_arg1); end
5016
+ def parent_reflection(*_arg0, &_arg1); end
4743
5017
  def parent_reflection=(arg); end
4744
- def plural_name(*args, &block); end
4745
- def polymorphic?(*args, &block); end
4746
- def polymorphic_inverse_of(*args, &block); end
4747
- def scope(*args, &block); end
4748
- def scope_for(*args, &block); end
5018
+ def plural_name(*_arg0, &_arg1); end
5019
+ def polymorphic?(*_arg0, &_arg1); end
5020
+ def polymorphic_inverse_of(*_arg0, &_arg1); end
5021
+ def scope(*_arg0, &_arg1); end
5022
+ def scope_for(*_arg0, &_arg1); end
4749
5023
  def scopes; end
4750
5024
  def source_options; end
4751
5025
  def source_reflection; end
@@ -4754,8 +5028,8 @@ class ActiveRecord::Reflection::ThroughReflection < ::ActiveRecord::Reflection::
4754
5028
  def through_options; end
4755
5029
  def through_reflection; end
4756
5030
  def through_reflection?; end
4757
- def type(*args, &block); end
4758
- def validate?(*args, &block); end
5031
+ def type(*_arg0, &_arg1); end
5032
+ def validate?(*_arg0, &_arg1); end
4759
5033
 
4760
5034
  protected
4761
5035
 
@@ -4784,11 +5058,10 @@ class ActiveRecord::Relation
4784
5058
  def initialize(klass, table: T.unsafe(nil), predicate_builder: T.unsafe(nil), values: T.unsafe(nil)); end
4785
5059
 
4786
5060
  def ==(other); end
4787
- def _deprecated_scope_source; end
4788
- def _exec_scope(name, *args, &block); end
5061
+ def _exec_scope(*args, &block); end
4789
5062
  def alias_tracker(joins = T.unsafe(nil), aliases = T.unsafe(nil)); end
4790
5063
  def any?; end
4791
- def arel_attribute(name); end
5064
+ def arel_attribute(*args, &block); end
4792
5065
  def bind_attribute(name, value); end
4793
5066
  def blank?; end
4794
5067
  def build(attributes = T.unsafe(nil), &block); end
@@ -4819,6 +5092,7 @@ class ActiveRecord::Relation
4819
5092
  def joined_includes_values; end
4820
5093
  def klass; end
4821
5094
  def load(&block); end
5095
+ def load_async; end
4822
5096
  def loaded; end
4823
5097
  def loaded?; end
4824
5098
  def locked?; end
@@ -4833,11 +5107,12 @@ class ActiveRecord::Relation
4833
5107
  def records; end
4834
5108
  def reload; end
4835
5109
  def reset; end
5110
+ def scheduled?; end
4836
5111
  def scope_for_create; end
4837
- def scoping; end
5112
+ def scoping(all_queries: T.unsafe(nil)); end
4838
5113
  def size; end
4839
5114
  def skip_preloading_value; end
4840
- def skip_preloading_value=(_); end
5115
+ def skip_preloading_value=(_arg0); end
4841
5116
  def table; end
4842
5117
  def to_a; end
4843
5118
  def to_ary; end
@@ -4847,27 +5122,31 @@ class ActiveRecord::Relation
4847
5122
  def update_all(updates); end
4848
5123
  def update_counters(counters); end
4849
5124
  def values; end
5125
+ def values_for_queries; end
4850
5126
  def where_values_hash(relation_table_name = T.unsafe(nil)); end
4851
5127
 
4852
5128
  protected
4853
5129
 
4854
- def _deprecated_scope_source=(_); end
4855
5130
  def load_records(records); end
4856
5131
  def null_relation?; end
4857
5132
 
4858
5133
  private
4859
5134
 
4860
- def _deprecated_scope_block(name, &block); end
4861
- def _deprecated_spawn(name); end
5135
+ def _create(attributes, &block); end
5136
+ def _create!(attributes, &block); end
4862
5137
  def _increment_attribute(attribute, value = T.unsafe(nil)); end
4863
- def _scoping(scope); end
5138
+ def _new(attributes, &block); end
5139
+ def _scoping(scope, all_queries = T.unsafe(nil)); end
4864
5140
  def _substitute_values(values); end
4865
5141
  def already_in_scope?; end
4866
- def build_preloader; end
4867
5142
  def compute_cache_key(timestamp_column = T.unsafe(nil)); end
4868
5143
  def compute_cache_version(timestamp_column); end
5144
+ def current_scope_restoring_block(&block); end
5145
+ def exec_main_query(async: T.unsafe(nil)); end
4869
5146
  def exec_queries(&block); end
5147
+ def global_scope?; end
4870
5148
  def initialize_copy(other); end
5149
+ def instantiate_records(rows, &block); end
4871
5150
  def references_eager_loaded_tables?; end
4872
5151
  def skip_query_cache_if_necessary; end
4873
5152
  def tables_in_string(string); end
@@ -4890,7 +5169,7 @@ class ActiveRecord::Relation::FromClause
4890
5169
  end
4891
5170
 
4892
5171
  class ActiveRecord::Relation::HashMerger
4893
- def initialize(relation, hash); end
5172
+ def initialize(relation, hash, rewhere = T.unsafe(nil)); end
4894
5173
 
4895
5174
  def hash; end
4896
5175
  def merge; end
@@ -4903,10 +5182,9 @@ ActiveRecord::Relation::INVALID_METHODS_FOR_DELETE_ALL = T.let(T.unsafe(nil), Ar
4903
5182
  ActiveRecord::Relation::MULTI_VALUE_METHODS = T.let(T.unsafe(nil), Array)
4904
5183
 
4905
5184
  class ActiveRecord::Relation::Merger
4906
- def initialize(relation, other); end
5185
+ def initialize(relation, other, rewhere = T.unsafe(nil)); end
4907
5186
 
4908
5187
  def merge; end
4909
- def normal_values; end
4910
5188
  def other; end
4911
5189
  def relation; end
4912
5190
  def values; end
@@ -4918,6 +5196,7 @@ class ActiveRecord::Relation::Merger
4918
5196
  def merge_multi_values; end
4919
5197
  def merge_outer_joins; end
4920
5198
  def merge_preloads; end
5199
+ def merge_select_values; end
4921
5200
  def merge_single_values; end
4922
5201
  def replace_from_clause?; end
4923
5202
  end
@@ -4954,16 +5233,19 @@ class ActiveRecord::Relation::WhereClause
4954
5233
  def +(other); end
4955
5234
  def -(other); end
4956
5235
  def ==(other); end
4957
- def any?(*args, &block); end
5236
+ def any?(*_arg0, &_arg1); end
4958
5237
  def ast; end
4959
5238
  def contradiction?; end
4960
- def each_attribute(&block); end
4961
- def empty?(*args, &block); end
5239
+ def empty?(*_arg0, &_arg1); end
5240
+ def eql?(other); end
4962
5241
  def except(*columns); end
4963
- def invert(as = T.unsafe(nil)); end
4964
- def merge(other); end
5242
+ def extract_attributes; end
5243
+ def hash; end
5244
+ def invert; end
5245
+ def merge(other, rewhere = T.unsafe(nil)); end
4965
5246
  def or(other); end
4966
- def to_h(table_name = T.unsafe(nil)); end
5247
+ def to_h(table_name = T.unsafe(nil), equality_only: T.unsafe(nil)); end
5248
+ def |(other); end
4967
5249
 
4968
5250
  protected
4969
5251
 
@@ -4972,9 +5254,11 @@ class ActiveRecord::Relation::WhereClause
4972
5254
 
4973
5255
  private
4974
5256
 
4975
- def equalities(predicates); end
5257
+ def each_attributes; end
5258
+ def equalities(predicates, equality_only); end
4976
5259
  def equality_node?(node); end
4977
5260
  def except_predicates(columns); end
5261
+ def extract_attribute(node); end
4978
5262
  def extract_node_value(node); end
4979
5263
  def invert_predicate(node); end
4980
5264
  def non_empty_predicates; end
@@ -4989,44 +5273,37 @@ end
4989
5273
 
4990
5274
  ActiveRecord::Relation::WhereClause::ARRAY_WITH_EMPTY_STRING = T.let(T.unsafe(nil), Array)
4991
5275
 
4992
- class ActiveRecord::Relation::WhereClauseFactory
4993
- def initialize(klass, predicate_builder); end
4994
-
4995
- def build(opts, other); end
4996
-
4997
- private
4998
-
4999
- def klass; end
5000
- def predicate_builder; end
5001
- end
5002
-
5003
5276
  class ActiveRecord::Result
5004
5277
  include(::Enumerable)
5005
5278
 
5006
5279
  def initialize(columns, rows, column_types = T.unsafe(nil)); end
5007
5280
 
5008
5281
  def [](idx); end
5282
+ def cancel; end
5009
5283
  def cast_values(type_overrides = T.unsafe(nil)); end
5010
- def collect!; end
5284
+ def collect!(*args, &block); end
5011
5285
  def column_types; end
5012
5286
  def columns; end
5013
5287
  def each; end
5014
5288
  def empty?; end
5015
- def first; end
5016
5289
  def includes_column?(name); end
5017
- def last; end
5290
+ def last(n = T.unsafe(nil)); end
5018
5291
  def length; end
5019
- def map!; end
5292
+ def map!(*args, &block); end
5293
+ def result; end
5020
5294
  def rows; end
5021
5295
  def to_a; end
5022
5296
  def to_ary; end
5023
- def to_hash; end
5024
5297
 
5025
5298
  private
5026
5299
 
5027
5300
  def column_type(name, type_overrides = T.unsafe(nil)); end
5028
5301
  def hash_rows; end
5029
5302
  def initialize_copy(other); end
5303
+
5304
+ class << self
5305
+ def empty; end
5306
+ end
5030
5307
  end
5031
5308
 
5032
5309
  class ActiveRecord::Rollback < ::ActiveRecord::ActiveRecordError
@@ -5035,14 +5312,10 @@ end
5035
5312
  class ActiveRecord::RuntimeRegistry
5036
5313
  extend(::ActiveSupport::PerThreadRegistry)
5037
5314
 
5038
- def connection_handler; end
5039
- def connection_handler=(_); end
5040
5315
  def sql_runtime; end
5041
- def sql_runtime=(_); end
5316
+ def sql_runtime=(_arg0); end
5042
5317
 
5043
5318
  class << self
5044
- def connection_handler; end
5045
- def connection_handler=(x); end
5046
5319
  def sql_runtime; end
5047
5320
  def sql_runtime=(x); end
5048
5321
  end
@@ -5084,6 +5357,8 @@ end
5084
5357
  class ActiveRecord::SchemaDumper
5085
5358
  def initialize(connection, options = T.unsafe(nil)); end
5086
5359
 
5360
+ def chk_ignore_pattern; end
5361
+ def chk_ignore_pattern=(val); end
5087
5362
  def dump(stream); end
5088
5363
  def fk_ignore_pattern; end
5089
5364
  def fk_ignore_pattern=(val); end
@@ -5092,6 +5367,7 @@ class ActiveRecord::SchemaDumper
5092
5367
 
5093
5368
  private
5094
5369
 
5370
+ def check_constraints_in_create(table, stream); end
5095
5371
  def define_params; end
5096
5372
  def extensions(stream); end
5097
5373
  def foreign_keys(table, stream); end
@@ -5107,11 +5383,13 @@ class ActiveRecord::SchemaDumper
5107
5383
  def remove_prefix_and_suffix(table); end
5108
5384
  def table(table, stream); end
5109
5385
  def table_name; end
5110
- def table_name=(_); end
5386
+ def table_name=(_arg0); end
5111
5387
  def tables(stream); end
5112
5388
  def trailer(stream); end
5113
5389
 
5114
5390
  class << self
5391
+ def chk_ignore_pattern; end
5392
+ def chk_ignore_pattern=(val); end
5115
5393
  def dump(connection = T.unsafe(nil), stream = T.unsafe(nil), config = T.unsafe(nil)); end
5116
5394
  def fk_ignore_pattern; end
5117
5395
  def fk_ignore_pattern=(val); end
@@ -5128,10 +5406,8 @@ class ActiveRecord::SchemaMigration < ::ActiveRecord::Base
5128
5406
  def version; end
5129
5407
 
5130
5408
  class << self
5131
- def _internal?; end
5132
5409
  def _validators; end
5133
5410
  def all_versions; end
5134
- def attribute_type_decorations; end
5135
5411
  def create_table; end
5136
5412
  def defined_enums; end
5137
5413
  def drop_table; end
@@ -5158,6 +5434,8 @@ end
5158
5434
  module ActiveRecord::Scoping::ClassMethods
5159
5435
  def current_scope(skip_inherited_scope = T.unsafe(nil)); end
5160
5436
  def current_scope=(scope); end
5437
+ def global_current_scope(skip_inherited_scope = T.unsafe(nil)); end
5438
+ def global_current_scope=(scope); end
5161
5439
  def scope_attributes; end
5162
5440
  def scope_attributes?; end
5163
5441
  end
@@ -5170,18 +5448,27 @@ end
5170
5448
 
5171
5449
  module ActiveRecord::Scoping::Default::ClassMethods
5172
5450
  def before_remove_const; end
5451
+ def default_scopes?(all_queries: T.unsafe(nil)); end
5173
5452
  def scope_attributes?; end
5174
5453
  def unscoped; end
5175
5454
 
5176
5455
  private
5177
5456
 
5178
- def build_default_scope(relation = T.unsafe(nil)); end
5179
- def default_scope(scope = T.unsafe(nil), &block); end
5457
+ def build_default_scope(relation = T.unsafe(nil), all_queries: T.unsafe(nil)); end
5458
+ def default_scope(scope = T.unsafe(nil), all_queries: T.unsafe(nil), &block); end
5180
5459
  def evaluate_default_scope; end
5460
+ def execute_scope?(all_queries, default_scope_obj); end
5181
5461
  def ignore_default_scope=(ignore); end
5182
5462
  def ignore_default_scope?; end
5183
5463
  end
5184
5464
 
5465
+ class ActiveRecord::Scoping::DefaultScope
5466
+ def initialize(scope, all_queries = T.unsafe(nil)); end
5467
+
5468
+ def all_queries; end
5469
+ def scope; end
5470
+ end
5471
+
5185
5472
  module ActiveRecord::Scoping::Named
5186
5473
  extend(::ActiveSupport::Concern)
5187
5474
 
@@ -5191,12 +5478,13 @@ end
5191
5478
  module ActiveRecord::Scoping::Named::ClassMethods
5192
5479
  def all; end
5193
5480
  def default_extensions; end
5194
- def default_scoped(scope = T.unsafe(nil)); end
5481
+ def default_scoped(scope = T.unsafe(nil), all_queries: T.unsafe(nil)); end
5195
5482
  def scope(name, body, &block); end
5196
5483
  def scope_for_association(scope = T.unsafe(nil)); end
5197
5484
 
5198
5485
  private
5199
5486
 
5487
+ def singleton_method_added(name); end
5200
5488
  def valid_scope_name?(name); end
5201
5489
  end
5202
5490
 
@@ -5245,10 +5533,32 @@ end
5245
5533
  class ActiveRecord::SerializationTypeMismatch < ::ActiveRecord::ActiveRecordError
5246
5534
  end
5247
5535
 
5536
+ module ActiveRecord::SignedId
5537
+ extend(::ActiveSupport::Concern)
5538
+
5539
+ mixes_in_class_methods(::ActiveRecord::SignedId::ClassMethods)
5540
+
5541
+ def signed_id(expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
5542
+ end
5543
+
5544
+ module ActiveRecord::SignedId::ClassMethods
5545
+ def combine_signed_id_purposes(purpose); end
5546
+ def find_signed(signed_id, purpose: T.unsafe(nil)); end
5547
+ def find_signed!(signed_id, purpose: T.unsafe(nil)); end
5548
+ def signed_id_verifier; end
5549
+ def signed_id_verifier=(verifier); end
5550
+ end
5551
+
5552
+ class ActiveRecord::SoleRecordExceeded < ::ActiveRecord::ActiveRecordError
5553
+ def initialize(record = T.unsafe(nil)); end
5554
+
5555
+ def record; end
5556
+ end
5557
+
5248
5558
  module ActiveRecord::SpawnMethods
5249
5559
  def except(*skips); end
5250
- def merge(other); end
5251
- def merge!(other); end
5560
+ def merge(other, *rest); end
5561
+ def merge!(other, *rest); end
5252
5562
  def only(*onlies); end
5253
5563
  def spawn; end
5254
5564
 
@@ -5305,8 +5615,9 @@ class ActiveRecord::StatementCache::PartialQueryCollector
5305
5615
 
5306
5616
  def <<(str); end
5307
5617
  def add_bind(obj); end
5618
+ def add_binds(binds, proc_for_binds = T.unsafe(nil)); end
5308
5619
  def preparable; end
5309
- def preparable=(_); end
5620
+ def preparable=(_arg0); end
5310
5621
  def value; end
5311
5622
  end
5312
5623
 
@@ -5392,8 +5703,8 @@ module ActiveRecord::Suppressor
5392
5703
 
5393
5704
  mixes_in_class_methods(::ActiveRecord::Suppressor::ClassMethods)
5394
5705
 
5395
- def save(**_); end
5396
- def save!(**_); end
5706
+ def save(**_arg0); end
5707
+ def save!(**_arg0); end
5397
5708
  end
5398
5709
 
5399
5710
  module ActiveRecord::Suppressor::ClassMethods
@@ -5409,33 +5720,27 @@ class ActiveRecord::SuppressorRegistry
5409
5720
  end
5410
5721
 
5411
5722
  class ActiveRecord::TableMetadata
5412
- def initialize(klass, arel_table, association = T.unsafe(nil), types = T.unsafe(nil)); end
5723
+ def initialize(klass, arel_table, reflection = T.unsafe(nil)); end
5413
5724
 
5414
5725
  def aggregated_with?(aggregation_name); end
5415
- def arel_attribute(column_name); end
5416
- def associated_predicate_builder(table_name); end
5726
+ def arel_table; end
5417
5727
  def associated_table(table_name); end
5418
- def associated_with?(association_name); end
5419
- def association_foreign_key(*args, &block); end
5420
- def association_foreign_type(*args, &block); end
5421
- def association_join_foreign_key(*args, &block); end
5422
- def association_join_primary_key(*args, &block); end
5728
+ def associated_with?(table_name); end
5423
5729
  def has_column?(column_name); end
5730
+ def join_foreign_key(*_arg0, &_arg1); end
5731
+ def join_foreign_type(*_arg0, &_arg1); end
5732
+ def join_primary_key(*_arg0, &_arg1); end
5424
5733
  def polymorphic_association?; end
5734
+ def predicate_builder; end
5735
+ def primary_key; end
5425
5736
  def reflect_on_aggregation(aggregation_name); end
5426
- def resolve_column_aliases(hash); end
5737
+ def through_association?; end
5427
5738
  def type(column_name); end
5428
5739
 
5429
- protected
5430
-
5431
- def predicate_builder; end
5432
-
5433
5740
  private
5434
5741
 
5435
- def arel_table; end
5436
- def association; end
5437
5742
  def klass; end
5438
- def types; end
5743
+ def reflection; end
5439
5744
  end
5440
5745
 
5441
5746
  class ActiveRecord::TableNotSpecified < ::ActiveRecord::ActiveRecordError
@@ -5448,7 +5753,7 @@ end
5448
5753
  module ActiveRecord::Tasks::DatabaseTasks
5449
5754
  extend(::ActiveRecord::Tasks::DatabaseTasks)
5450
5755
 
5451
- def cache_dump_filename(name, schema_cache_path: T.unsafe(nil)); end
5756
+ def cache_dump_filename(db_config_name, schema_cache_path: T.unsafe(nil)); end
5452
5757
  def charset(configuration, *arguments); end
5453
5758
  def charset_current(env_name = T.unsafe(nil), db_name = T.unsafe(nil)); end
5454
5759
  def check_protected_environments!; end
@@ -5463,19 +5768,19 @@ module ActiveRecord::Tasks::DatabaseTasks
5463
5768
  def current_config(*args, &block); end
5464
5769
  def current_config=(*args, &block); end
5465
5770
  def database_configuration; end
5466
- def database_configuration=(_); end
5771
+ def database_configuration=(_arg0); end
5467
5772
  def db_dir; end
5468
- def db_dir=(_); end
5773
+ def db_dir=(_arg0); end
5469
5774
  def drop(configuration, *arguments); end
5470
5775
  def drop_all; end
5471
5776
  def drop_current(environment = T.unsafe(nil)); end
5472
- def dump_filename(name, format = T.unsafe(nil)); end
5777
+ def dump_filename(db_config_name, format = T.unsafe(nil)); end
5473
5778
  def dump_schema(db_config, format = T.unsafe(nil)); end
5474
5779
  def dump_schema_cache(conn, filename); end
5475
5780
  def env; end
5476
- def env=(_); end
5781
+ def env=(_arg0); end
5477
5782
  def fixtures_path; end
5478
- def fixtures_path=(_); end
5783
+ def fixtures_path=(_arg0); end
5479
5784
  def for_each(databases); end
5480
5785
  def load_schema(db_config, format = T.unsafe(nil), file = T.unsafe(nil)); end
5481
5786
  def load_schema_current(format = T.unsafe(nil), file = T.unsafe(nil), environment = T.unsafe(nil)); end
@@ -5483,8 +5788,9 @@ module ActiveRecord::Tasks::DatabaseTasks
5483
5788
  def migrate; end
5484
5789
  def migrate_status; end
5485
5790
  def migrations_paths; end
5486
- def migrations_paths=(_); end
5791
+ def migrations_paths=(_arg0); end
5487
5792
  def name; end
5793
+ def prepare_all; end
5488
5794
  def purge(configuration); end
5489
5795
  def purge_all; end
5490
5796
  def purge_current(environment = T.unsafe(nil)); end
@@ -5492,12 +5798,12 @@ module ActiveRecord::Tasks::DatabaseTasks
5492
5798
  def reconstruct_from_schema(db_config, format = T.unsafe(nil), file = T.unsafe(nil)); end
5493
5799
  def register_task(pattern, task); end
5494
5800
  def root; end
5495
- def root=(_); end
5496
- def schema_file(format = T.unsafe(nil)); end
5801
+ def root=(_arg0); end
5802
+ def schema_file(*args, &block); end
5497
5803
  def schema_file_type(format = T.unsafe(nil)); end
5498
5804
  def schema_up_to_date?(configuration, format = T.unsafe(nil), file = T.unsafe(nil), environment = T.unsafe(nil), name = T.unsafe(nil)); end
5499
5805
  def seed_loader; end
5500
- def seed_loader=(_); end
5806
+ def seed_loader=(_arg0); end
5501
5807
  def setup_initial_database_yaml; end
5502
5808
  def spec(*args, &block); end
5503
5809
  def structure_dump(configuration, *arguments); end
@@ -5508,12 +5814,15 @@ module ActiveRecord::Tasks::DatabaseTasks
5508
5814
  private
5509
5815
 
5510
5816
  def class_for_adapter(adapter); end
5817
+ def configs_for(**options); end
5511
5818
  def database_adapter_for(db_config, *arguments); end
5512
5819
  def each_current_configuration(environment, name = T.unsafe(nil)); end
5513
5820
  def each_local_configuration; end
5514
5821
  def local_database?(db_config); end
5515
5822
  def resolve_configuration(configuration); end
5516
5823
  def schema_sha1(file); end
5824
+ def structure_dump_flags_for(adapter); end
5825
+ def structure_load_flags_for(adapter); end
5517
5826
  def truncate_tables(db_config); end
5518
5827
  def verbose?; end
5519
5828
 
@@ -5532,10 +5841,10 @@ class ActiveRecord::Tasks::MySQLDatabaseTasks
5532
5841
 
5533
5842
  def charset; end
5534
5843
  def collation; end
5535
- def connection(*args, &block); end
5844
+ def connection(*_arg0, &_arg1); end
5536
5845
  def create; end
5537
5846
  def drop; end
5538
- def establish_connection(*args, &block); end
5847
+ def establish_connection(*_arg0, &_arg1); end
5539
5848
  def purge; end
5540
5849
  def structure_dump(filename, extra_flags); end
5541
5850
  def structure_load(filename, extra_flags); end
@@ -5561,12 +5870,12 @@ class ActiveRecord::Tasks::PostgreSQLDatabaseTasks
5561
5870
  def initialize(db_config); end
5562
5871
 
5563
5872
  def charset; end
5564
- def clear_active_connections!(*args, &block); end
5873
+ def clear_active_connections!(*_arg0, &_arg1); end
5565
5874
  def collation; end
5566
- def connection(*args, &block); end
5875
+ def connection(*_arg0, &_arg1); end
5567
5876
  def create(master_established = T.unsafe(nil)); end
5568
5877
  def drop; end
5569
- def establish_connection(*args, &block); end
5878
+ def establish_connection(*_arg0, &_arg1); end
5570
5879
  def purge; end
5571
5880
  def structure_dump(filename, extra_flags); end
5572
5881
  def structure_load(filename, extra_flags); end
@@ -5597,10 +5906,10 @@ class ActiveRecord::Tasks::SQLiteDatabaseTasks
5597
5906
  def initialize(db_config, root = T.unsafe(nil)); end
5598
5907
 
5599
5908
  def charset; end
5600
- def connection(*args, &block); end
5909
+ def connection(*_arg0, &_arg1); end
5601
5910
  def create; end
5602
5911
  def drop; end
5603
- def establish_connection(*args, &block); end
5912
+ def establish_connection(*_arg0, &_arg1); end
5604
5913
  def purge; end
5605
5914
  def structure_dump(filename, extra_flags); end
5606
5915
  def structure_load(filename, extra_flags); end
@@ -5671,7 +5980,7 @@ module ActiveRecord::Timestamp
5671
5980
  def _update_record; end
5672
5981
  def all_timestamp_attributes_in_model; end
5673
5982
  def clear_timestamp_attributes; end
5674
- def create_or_update(touch: T.unsafe(nil), **_); end
5983
+ def create_or_update(touch: T.unsafe(nil), **_arg1); end
5675
5984
  def current_time_from_proper_timezone; end
5676
5985
  def initialize_dup(other); end
5677
5986
  def max_updated_column_timestamp; end
@@ -5703,7 +6012,7 @@ module ActiveRecord::TouchLater
5703
6012
 
5704
6013
  def belongs_to_touch_method; end
5705
6014
  def has_defer_touch_attrs?; end
5706
- def surreptitiously_touch(attrs); end
6015
+ def surreptitiously_touch(attr_names); end
5707
6016
  def touch_deferred_attributes; end
5708
6017
  end
5709
6018
 
@@ -5722,9 +6031,9 @@ module ActiveRecord::Transactions
5722
6031
  def committed!(should_run_callbacks: T.unsafe(nil)); end
5723
6032
  def destroy; end
5724
6033
  def rolledback!(force_restore_state: T.unsafe(nil), should_run_callbacks: T.unsafe(nil)); end
5725
- def save(**_); end
5726
- def save!(**_); end
5727
- def touch(*_, **_); end
6034
+ def save(**_arg0); end
6035
+ def save!(**_arg0); end
6036
+ def touch(*_arg0, **_arg1); end
5728
6037
  def transaction(**options, &block); end
5729
6038
  def trigger_transactional_callbacks?; end
5730
6039
  def with_transaction_returning_status; end
@@ -5734,13 +6043,11 @@ module ActiveRecord::Transactions
5734
6043
  def _committed_already_called; end
5735
6044
  def _trigger_destroy_callback; end
5736
6045
  def _trigger_update_callback; end
5737
- def add_to_transaction; end
6046
+ def add_to_transaction(ensure_finalize = T.unsafe(nil)); end
5738
6047
  def clear_transaction_record_state; end
5739
- def force_clear_transaction_record_state; end
5740
6048
  def has_transactional_callbacks?; end
5741
6049
  def remember_transaction_record_state; end
5742
6050
  def restore_transaction_record_state(force_restore_state = T.unsafe(nil)); end
5743
- def sync_with_transaction_state; end
5744
6051
  def transaction_include_any_action?(actions); end
5745
6052
  end
5746
6053
 
@@ -5773,12 +6080,12 @@ end
5773
6080
  module ActiveRecord::Type
5774
6081
  class << self
5775
6082
  def adapter_name_from(model); end
5776
- def add_modifier(*args, &block); end
6083
+ def add_modifier(*_arg0, &_arg1); end
5777
6084
  def default_value; end
5778
6085
  def lookup(*args, adapter: T.unsafe(nil), **kwargs); end
5779
6086
  def register(type_name, klass = T.unsafe(nil), **options, &block); end
5780
6087
  def registry; end
5781
- def registry=(_); end
6088
+ def registry=(_arg0); end
5782
6089
 
5783
6090
  private
5784
6091
 
@@ -5842,6 +6149,8 @@ class ActiveRecord::Type::HashLookupTypeMap < ::ActiveRecord::Type::TypeMap
5842
6149
  def perform_fetch(type, *args, &block); end
5843
6150
  end
5844
6151
 
6152
+ ActiveRecord::Type::ImmutableString = ActiveModel::Type::ImmutableString
6153
+
5845
6154
  ActiveRecord::Type::Integer = ActiveModel::Type::Integer
5846
6155
 
5847
6156
  module ActiveRecord::Type::Internal
@@ -5882,7 +6191,7 @@ class ActiveRecord::Type::Registration
5882
6191
 
5883
6192
  def conflicts_with?(other); end
5884
6193
  def has_adapter_conflict?(other); end
5885
- def matches_adapter?(adapter: T.unsafe(nil), **_); end
6194
+ def matches_adapter?(adapter: T.unsafe(nil), **_arg1); end
5886
6195
  def same_priority_except_adapter?(other); end
5887
6196
  end
5888
6197
 
@@ -5917,6 +6226,10 @@ class ActiveRecord::Type::Time < ::ActiveModel::Type::Time
5917
6226
  include(::ActiveRecord::Type::Internal::Timezone)
5918
6227
 
5919
6228
  def serialize(value); end
6229
+
6230
+ private
6231
+
6232
+ def cast_value(value); end
5920
6233
  end
5921
6234
 
5922
6235
  class ActiveRecord::Type::Time::Value
@@ -5957,19 +6270,19 @@ class ActiveRecord::TypeCaster::Connection
5957
6270
 
5958
6271
  private
5959
6272
 
5960
- def connection(*args, &block); end
6273
+ def connection(*_arg0, &_arg1); end
5961
6274
  def table_name; end
5962
6275
  end
5963
6276
 
5964
6277
  class ActiveRecord::TypeCaster::Map
5965
- def initialize(types); end
6278
+ def initialize(klass); end
5966
6279
 
5967
6280
  def type_cast_for_database(attr_name, value); end
5968
6281
  def type_for_attribute(name); end
5969
6282
 
5970
6283
  private
5971
6284
 
5972
- def types; end
6285
+ def klass; end
5973
6286
  end
5974
6287
 
5975
6288
  class ActiveRecord::TypeConflictError < ::StandardError
@@ -6083,17 +6396,18 @@ class ActiveRecord::Associations::JoinDependency::JoinPart
6083
6396
 
6084
6397
  def initialize(base_klass, children); end
6085
6398
 
6399
+ def attribute_types(*_arg0, &_arg1); end
6086
6400
  def base_klass; end
6087
6401
  def children; end
6088
- def column_names(*args, &block); end
6402
+ def column_names(*_arg0, &_arg1); end
6089
6403
  def each(&block); end
6090
6404
  def each_children(&block); end
6091
6405
  def extract_record(row, column_names_with_alias); end
6092
- def instantiate(row, aliases, &block); end
6406
+ def instantiate(row, aliases, column_types = T.unsafe(nil), &block); end
6093
6407
  def match?(other); end
6094
- def primary_key(*args, &block); end
6408
+ def primary_key(*_arg0, &_arg1); end
6095
6409
  def table; end
6096
- def table_name(*args, &block); end
6410
+ def table_name(*_arg0, &_arg1); end
6097
6411
  end
6098
6412
 
6099
6413
  class ActiveRecord::ConcurrentMigrationError < ::ActiveRecord::MigrationError
@@ -6104,15 +6418,20 @@ ActiveRecord::ConcurrentMigrationError::DEFAULT_MESSAGE = T.let(T.unsafe(nil), S
6104
6418
 
6105
6419
  ActiveRecord::ConcurrentMigrationError::RELEASE_LOCK_FAILED_MESSAGE = T.let(T.unsafe(nil), String)
6106
6420
 
6421
+ module ActiveRecord::ConnectionAdapters::AbstractPool
6422
+ def get_schema_cache(connection); end
6423
+ def set_schema_cache(cache); end
6424
+ end
6425
+
6107
6426
  class ActiveRecord::ConnectionAdapters::AddColumnDefinition < ::Struct
6108
6427
  def column; end
6109
6428
  def column=(_); end
6110
6429
 
6111
6430
  class << self
6112
- def [](*_); end
6431
+ def [](*_arg0); end
6113
6432
  def inspect; end
6114
6433
  def members; end
6115
- def new(*_); end
6434
+ def new(*_arg0); end
6116
6435
  end
6117
6436
  end
6118
6437
 
@@ -6131,6 +6450,22 @@ module ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods
6131
6450
  def define_column_methods(*column_types); end
6132
6451
  end
6133
6452
 
6453
+ class ActiveRecord::ConnectionAdapters::CreateIndexDefinition < ::Struct
6454
+ def algorithm; end
6455
+ def algorithm=(_); end
6456
+ def if_not_exists; end
6457
+ def if_not_exists=(_); end
6458
+ def index; end
6459
+ def index=(_); end
6460
+
6461
+ class << self
6462
+ def [](*_arg0); end
6463
+ def inspect; end
6464
+ def members; end
6465
+ def new(*_arg0); end
6466
+ end
6467
+ end
6468
+
6134
6469
  module ActiveRecord::ConnectionAdapters::Deduplicable
6135
6470
  extend(::ActiveSupport::Concern)
6136
6471
 
@@ -6145,12 +6480,12 @@ module ActiveRecord::ConnectionAdapters::Deduplicable
6145
6480
  end
6146
6481
 
6147
6482
  module ActiveRecord::ConnectionAdapters::Deduplicable::ClassMethods
6148
- def new(*_, **_); end
6483
+ def new(*_arg0, **_arg1); end
6149
6484
  def registry; end
6150
6485
  end
6151
6486
 
6152
6487
  class ActiveRecord::ConnectionAdapters::NullColumn < ::ActiveRecord::ConnectionAdapters::Column
6153
- def initialize(name, **_); end
6488
+ def initialize(name, **_arg1); end
6154
6489
  end
6155
6490
 
6156
6491
  class ActiveRecord::ConnectionAdapters::PrimaryKeyDefinition < ::Struct
@@ -6158,10 +6493,10 @@ class ActiveRecord::ConnectionAdapters::PrimaryKeyDefinition < ::Struct
6158
6493
  def name=(_); end
6159
6494
 
6160
6495
  class << self
6161
- def [](*_); end
6496
+ def [](*_arg0); end
6162
6497
  def inspect; end
6163
6498
  def members; end
6164
- def new(*_); end
6499
+ def new(*_arg0); end
6165
6500
  end
6166
6501
  end
6167
6502
 
@@ -6175,7 +6510,7 @@ class ActiveRecord::ConnectionAdapters::SchemaCache
6175
6510
  def columns_hash(table_name); end
6176
6511
  def columns_hash?(table_name); end
6177
6512
  def connection; end
6178
- def connection=(_); end
6513
+ def connection=(_arg0); end
6179
6514
  def data_source_exists?(name); end
6180
6515
  def data_sources(name); end
6181
6516
  def database_version; end
@@ -6216,24 +6551,34 @@ class ActiveRecord::ConnectionAdapters::SchemaCreation
6216
6551
 
6217
6552
  def action_sql(action, dependency); end
6218
6553
  def add_column_options!(sql, options); end
6219
- def add_table_options!(create_sql, options); end
6554
+ def add_table_options!(create_sql, o); end
6555
+ def check_constraint_in_create(table_name, expression, options); end
6556
+ def check_constraint_options(*_arg0, &_arg1); end
6220
6557
  def column_options(o); end
6221
6558
  def foreign_key_in_create(from_table, to_table, options); end
6222
- def foreign_key_options(*args, &block); end
6223
- def options_include_default?(*args, &block); end
6224
- def quote_column_name(*args, &block); end
6225
- def quote_default_expression(*args, &block); end
6226
- def quote_table_name(*args, &block); end
6227
- def supports_foreign_keys?(*args, &block); end
6228
- def supports_indexes_in_create?(*args, &block); end
6559
+ def foreign_key_options(*_arg0, &_arg1); end
6560
+ def options_include_default?(*_arg0, &_arg1); end
6561
+ def quote_column_name(*_arg0, &_arg1); end
6562
+ def quote_default_expression(*_arg0, &_arg1); end
6563
+ def quote_table_name(*_arg0, &_arg1); end
6564
+ def quoted_columns(o); end
6565
+ def quoted_columns_for_index(*_arg0, &_arg1); end
6566
+ def supports_check_constraints?(*_arg0, &_arg1); end
6567
+ def supports_foreign_keys?(*_arg0, &_arg1); end
6568
+ def supports_index_using?; end
6569
+ def supports_indexes_in_create?(*_arg0, &_arg1); end
6570
+ def supports_partial_index?(*_arg0, &_arg1); end
6229
6571
  def table_modifier_in_create(o); end
6230
- def table_options(o); end
6231
6572
  def to_sql(sql); end
6232
- def type_to_sql(*args, &block); end
6573
+ def type_to_sql(*_arg0, &_arg1); end
6574
+ def visit_AddCheckConstraint(o); end
6233
6575
  def visit_AddColumnDefinition(o); end
6234
6576
  def visit_AddForeignKey(o); end
6235
6577
  def visit_AlterTable(o); end
6578
+ def visit_CheckConstraintDefinition(o); end
6236
6579
  def visit_ColumnDefinition(o); end
6580
+ def visit_CreateIndexDefinition(o); end
6581
+ def visit_DropCheckConstraint(name); end
6237
6582
  def visit_DropForeignKey(name); end
6238
6583
  def visit_ForeignKeyDefinition(o); end
6239
6584
  def visit_PrimaryKeyDefinition(o); end
@@ -6286,7 +6631,7 @@ end
6286
6631
  class ActiveRecord::ConnectionAdapters::Transaction
6287
6632
  def initialize(connection, isolation: T.unsafe(nil), joinable: T.unsafe(nil), run_commit_callbacks: T.unsafe(nil)); end
6288
6633
 
6289
- def add_record(record); end
6634
+ def add_record(record, ensure_finalize = T.unsafe(nil)); end
6290
6635
  def before_commit_records; end
6291
6636
  def closed?; end
6292
6637
  def commit_records; end
@@ -6301,6 +6646,11 @@ class ActiveRecord::ConnectionAdapters::Transaction
6301
6646
  def rollback_records; end
6302
6647
  def savepoint_name; end
6303
6648
  def state; end
6649
+ def written; end
6650
+ def written=(_arg0); end
6651
+ end
6652
+
6653
+ class ActiveRecord::DestroyAssociationAsyncError < ::StandardError
6304
6654
  end
6305
6655
 
6306
6656
  class ActiveRecord::DuplicateMigrationNameError < ::ActiveRecord::MigrationError
@@ -6381,6 +6731,7 @@ class ActiveRecord::FixtureSet
6381
6731
  def instantiate_all_loaded_fixtures(object, load_instances = T.unsafe(nil)); end
6382
6732
  def instantiate_fixtures(object, fixture_set, load_instances = T.unsafe(nil)); end
6383
6733
  def reset_cache; end
6734
+ def signed_global_id(fixture_set_name, label, column_type: T.unsafe(nil), **options); end
6384
6735
 
6385
6736
  private
6386
6737
 
@@ -6463,6 +6814,7 @@ class ActiveRecord::FixtureSet::TableRow::HasManyThroughProxy < ::ActiveRecord::
6463
6814
  def join_table; end
6464
6815
  def lhs_key; end
6465
6816
  def rhs_key; end
6817
+ def timestamp_column_names; end
6466
6818
  end
6467
6819
 
6468
6820
  class ActiveRecord::FixtureSet::TableRow::ReflectionProxy
@@ -6494,9 +6846,8 @@ class ActiveRecord::IrreversibleMigration < ::ActiveRecord::MigrationError
6494
6846
  end
6495
6847
 
6496
6848
  class ActiveRecord::MigrationContext
6497
- def initialize(migrations_paths, schema_migration); end
6849
+ def initialize(migrations_paths, schema_migration = T.unsafe(nil)); end
6498
6850
 
6499
- def any_migrations?; end
6500
6851
  def current_environment; end
6501
6852
  def current_version; end
6502
6853
  def down(target_version = T.unsafe(nil)); end
@@ -6529,19 +6880,19 @@ end
6529
6880
  class ActiveRecord::MigrationProxy < ::Struct
6530
6881
  def initialize(name, version, filename, scope); end
6531
6882
 
6532
- def announce(*args, &block); end
6883
+ def announce(*_arg0, &_arg1); end
6533
6884
  def basename; end
6534
- def disable_ddl_transaction(*args, &block); end
6885
+ def disable_ddl_transaction(*_arg0, &_arg1); end
6535
6886
  def filename; end
6536
6887
  def filename=(_); end
6537
- def migrate(*args, &block); end
6888
+ def migrate(*_arg0, &_arg1); end
6538
6889
  def name; end
6539
6890
  def name=(_); end
6540
6891
  def scope; end
6541
6892
  def scope=(_); end
6542
6893
  def version; end
6543
6894
  def version=(_); end
6544
- def write(*args, &block); end
6895
+ def write(*_arg0, &_arg1); end
6545
6896
 
6546
6897
  private
6547
6898
 
@@ -6549,10 +6900,10 @@ class ActiveRecord::MigrationProxy < ::Struct
6549
6900
  def migration; end
6550
6901
 
6551
6902
  class << self
6552
- def [](*_); end
6903
+ def [](*_arg0); end
6553
6904
  def inspect; end
6554
6905
  def members; end
6555
- def new(*_); end
6906
+ def new(*_arg0); end
6556
6907
  end
6557
6908
  end
6558
6909
 
@@ -6567,9 +6918,13 @@ class ActiveRecord::PendingMigrationError < ::ActiveRecord::MigrationError
6567
6918
  def initialize(message = T.unsafe(nil)); end
6568
6919
 
6569
6920
  def _actions; end
6570
- def _actions=(_); end
6921
+ def _actions=(_arg0); end
6571
6922
  def _actions?; end
6572
6923
 
6924
+ private
6925
+
6926
+ def detailed_migration_message; end
6927
+
6573
6928
  class << self
6574
6929
  def _actions; end
6575
6930
  def _actions=(value); end
@@ -6622,27 +6977,6 @@ class Arel::Attributes::Attribute < ::Struct
6622
6977
  def type_caster; end
6623
6978
  end
6624
6979
 
6625
- class Arel::Attributes::Boolean < ::Arel::Attributes::Attribute
6626
- end
6627
-
6628
- class Arel::Attributes::Decimal < ::Arel::Attributes::Attribute
6629
- end
6630
-
6631
- class Arel::Attributes::Float < ::Arel::Attributes::Attribute
6632
- end
6633
-
6634
- class Arel::Attributes::Integer < ::Arel::Attributes::Attribute
6635
- end
6636
-
6637
- class Arel::Attributes::String < ::Arel::Attributes::Attribute
6638
- end
6639
-
6640
- class Arel::Attributes::Time < ::Arel::Attributes::Attribute
6641
- end
6642
-
6643
- class Arel::Attributes::Undefined < ::Arel::Attributes::Attribute
6644
- end
6645
-
6646
6980
  module Arel::Collectors
6647
6981
  end
6648
6982
 
@@ -6651,6 +6985,7 @@ class Arel::Collectors::Bind
6651
6985
 
6652
6986
  def <<(str); end
6653
6987
  def add_bind(bind); end
6988
+ def add_binds(binds, proc_for_binds = T.unsafe(nil)); end
6654
6989
  def value; end
6655
6990
  end
6656
6991
 
@@ -6659,8 +6994,9 @@ class Arel::Collectors::Composite
6659
6994
 
6660
6995
  def <<(str); end
6661
6996
  def add_bind(bind, &block); end
6997
+ def add_binds(binds, proc_for_binds = T.unsafe(nil), &block); end
6662
6998
  def preparable; end
6663
- def preparable=(_); end
6999
+ def preparable=(_arg0); end
6664
7000
  def value; end
6665
7001
 
6666
7002
  private
@@ -6677,11 +7013,12 @@ class Arel::Collectors::PlainString
6677
7013
  end
6678
7014
 
6679
7015
  class Arel::Collectors::SQLString < ::Arel::Collectors::PlainString
6680
- def initialize(*_); end
7016
+ def initialize(*_arg0); end
6681
7017
 
6682
7018
  def add_bind(bind); end
7019
+ def add_binds(binds, proc_for_binds = T.unsafe(nil), &block); end
6683
7020
  def preparable; end
6684
- def preparable=(_); end
7021
+ def preparable=(_arg0); end
6685
7022
  end
6686
7023
 
6687
7024
  class Arel::Collectors::SubstituteBinds
@@ -6689,8 +7026,9 @@ class Arel::Collectors::SubstituteBinds
6689
7026
 
6690
7027
  def <<(str); end
6691
7028
  def add_bind(bind); end
7029
+ def add_binds(binds, proc_for_binds = T.unsafe(nil)); end
6692
7030
  def preparable; end
6693
- def preparable=(_); end
7031
+ def preparable=(_arg0); end
6694
7032
  def value; end
6695
7033
 
6696
7034
  private
@@ -6700,16 +7038,16 @@ class Arel::Collectors::SubstituteBinds
6700
7038
  end
6701
7039
 
6702
7040
  module Arel::Crud
6703
- def compile_delete; end
7041
+ def compile_delete(key = T.unsafe(nil)); end
6704
7042
  def compile_insert(values); end
6705
- def compile_update(values, pk); end
7043
+ def compile_update(values, key = T.unsafe(nil)); end
6706
7044
  def create_insert; end
6707
7045
  end
6708
7046
 
6709
7047
  class Arel::DeleteManager < ::Arel::TreeManager
6710
7048
  include(::Arel::TreeManager::StatementMethods)
6711
7049
 
6712
- def initialize; end
7050
+ def initialize(table = T.unsafe(nil)); end
6713
7051
 
6714
7052
  def from(relation); end
6715
7053
  end
@@ -6740,7 +7078,7 @@ module Arel::FactoryMethods
6740
7078
  end
6741
7079
 
6742
7080
  class Arel::InsertManager < ::Arel::TreeManager
6743
- def initialize; end
7081
+ def initialize(table = T.unsafe(nil)); end
6744
7082
 
6745
7083
  def columns; end
6746
7084
  def create_values(values); end
@@ -6815,9 +7153,9 @@ class Arel::Nodes::Binary < ::Arel::Nodes::NodeExpression
6815
7153
  def eql?(other); end
6816
7154
  def hash; end
6817
7155
  def left; end
6818
- def left=(_); end
7156
+ def left=(_arg0); end
6819
7157
  def right; end
6820
- def right=(_); end
7158
+ def right=(_arg0); end
6821
7159
 
6822
7160
  private
6823
7161
 
@@ -6866,11 +7204,11 @@ class Arel::Nodes::Case < ::Arel::Nodes::NodeExpression
6866
7204
 
6867
7205
  def ==(other); end
6868
7206
  def case; end
6869
- def case=(_); end
7207
+ def case=(_arg0); end
6870
7208
  def conditions; end
6871
- def conditions=(_); end
7209
+ def conditions=(_arg0); end
6872
7210
  def default; end
6873
- def default=(_); end
7211
+ def default=(_arg0); end
6874
7212
  def else(expression); end
6875
7213
  def eql?(other); end
6876
7214
  def hash; end
@@ -6912,6 +7250,10 @@ class Arel::Nodes::Concat < ::Arel::Nodes::InfixOperation
6912
7250
  def initialize(left, right); end
6913
7251
  end
6914
7252
 
7253
+ class Arel::Nodes::Contains < ::Arel::Nodes::InfixOperation
7254
+ def initialize(left, right); end
7255
+ end
7256
+
6915
7257
  class Arel::Nodes::Count < ::Arel::Nodes::Function
6916
7258
  def initialize(expr, distinct = T.unsafe(nil), aliaz = T.unsafe(nil)); end
6917
7259
  end
@@ -6932,21 +7274,17 @@ class Arel::Nodes::DeleteStatement < ::Arel::Nodes::Node
6932
7274
  def eql?(other); end
6933
7275
  def hash; end
6934
7276
  def key; end
6935
- def key=(_); end
6936
- def left; end
6937
- def left=(_); end
7277
+ def key=(_arg0); end
6938
7278
  def limit; end
6939
- def limit=(_); end
7279
+ def limit=(_arg0); end
6940
7280
  def offset; end
6941
- def offset=(_); end
7281
+ def offset=(_arg0); end
6942
7282
  def orders; end
6943
- def orders=(_); end
7283
+ def orders=(_arg0); end
6944
7284
  def relation; end
6945
- def relation=(_); end
6946
- def right; end
6947
- def right=(_); end
7285
+ def relation=(_arg0); end
6948
7286
  def wheres; end
6949
- def wheres=(_); end
7287
+ def wheres=(_arg0); end
6950
7288
 
6951
7289
  private
6952
7290
 
@@ -6980,10 +7318,10 @@ class Arel::Nodes::Else < ::Arel::Nodes::Unary
6980
7318
  end
6981
7319
 
6982
7320
  class Arel::Nodes::Equality < ::Arel::Nodes::Binary
7321
+ include(::Arel::Nodes::FetchAttribute)
7322
+
6983
7323
  def equality?; end
6984
- def fetch_attribute; end
6985
7324
  def invert; end
6986
- def operator; end
6987
7325
  end
6988
7326
 
6989
7327
  class Arel::Nodes::Except < ::Arel::Nodes::Binary
@@ -6998,7 +7336,7 @@ class Arel::Nodes::Extract < ::Arel::Nodes::Unary
6998
7336
  def ==(other); end
6999
7337
  def eql?(other); end
7000
7338
  def field; end
7001
- def field=(_); end
7339
+ def field=(_arg0); end
7002
7340
  def hash; end
7003
7341
  end
7004
7342
 
@@ -7026,22 +7364,26 @@ class Arel::Nodes::Function < ::Arel::Nodes::NodeExpression
7026
7364
 
7027
7365
  def ==(other); end
7028
7366
  def alias; end
7029
- def alias=(_); end
7367
+ def alias=(_arg0); end
7030
7368
  def as(aliaz); end
7031
7369
  def distinct; end
7032
- def distinct=(_); end
7370
+ def distinct=(_arg0); end
7033
7371
  def eql?(other); end
7034
7372
  def expressions; end
7035
- def expressions=(_); end
7373
+ def expressions=(_arg0); end
7036
7374
  def hash; end
7037
7375
  end
7038
7376
 
7039
7377
  class Arel::Nodes::GreaterThan < ::Arel::Nodes::Binary
7040
7378
  include(::Arel::Nodes::FetchAttribute)
7379
+
7380
+ def invert; end
7041
7381
  end
7042
7382
 
7043
7383
  class Arel::Nodes::GreaterThanOrEqual < ::Arel::Nodes::Binary
7044
7384
  include(::Arel::Nodes::FetchAttribute)
7385
+
7386
+ def invert; end
7045
7387
  end
7046
7388
 
7047
7389
  class Arel::Nodes::Group < ::Arel::Nodes::Unary
@@ -7070,6 +7412,8 @@ class Arel::Nodes::HomogeneousIn < ::Arel::Nodes::Node
7070
7412
  def hash; end
7071
7413
  def invert; end
7072
7414
  def left; end
7415
+ def proc_for_binds; end
7416
+ def right; end
7073
7417
  def table_name; end
7074
7418
  def type; end
7075
7419
  def values; end
@@ -7079,7 +7423,10 @@ class Arel::Nodes::HomogeneousIn < ::Arel::Nodes::Node
7079
7423
  def ivars; end
7080
7424
  end
7081
7425
 
7082
- class Arel::Nodes::In < ::Arel::Nodes::Equality
7426
+ class Arel::Nodes::In < ::Arel::Nodes::Binary
7427
+ include(::Arel::Nodes::FetchAttribute)
7428
+
7429
+ def equality?; end
7083
7430
  def invert; end
7084
7431
  end
7085
7432
 
@@ -7093,19 +7440,19 @@ class Arel::Nodes::InnerJoin < ::Arel::Nodes::Join
7093
7440
  end
7094
7441
 
7095
7442
  class Arel::Nodes::InsertStatement < ::Arel::Nodes::Node
7096
- def initialize; end
7443
+ def initialize(relation = T.unsafe(nil)); end
7097
7444
 
7098
7445
  def ==(other); end
7099
7446
  def columns; end
7100
- def columns=(_); end
7447
+ def columns=(_arg0); end
7101
7448
  def eql?(other); end
7102
7449
  def hash; end
7103
7450
  def relation; end
7104
- def relation=(_); end
7451
+ def relation=(_arg0); end
7105
7452
  def select; end
7106
- def select=(_); end
7453
+ def select=(_arg0); end
7107
7454
  def values; end
7108
- def values=(_); end
7455
+ def values=(_arg0); end
7109
7456
 
7110
7457
  private
7111
7458
 
@@ -7115,11 +7462,15 @@ end
7115
7462
  class Arel::Nodes::Intersect < ::Arel::Nodes::Binary
7116
7463
  end
7117
7464
 
7118
- class Arel::Nodes::IsDistinctFrom < ::Arel::Nodes::Equality
7465
+ class Arel::Nodes::IsDistinctFrom < ::Arel::Nodes::Binary
7466
+ include(::Arel::Nodes::FetchAttribute)
7467
+
7119
7468
  def invert; end
7120
7469
  end
7121
7470
 
7122
- class Arel::Nodes::IsNotDistinctFrom < ::Arel::Nodes::Equality
7471
+ class Arel::Nodes::IsNotDistinctFrom < ::Arel::Nodes::Binary
7472
+ include(::Arel::Nodes::FetchAttribute)
7473
+
7123
7474
  def invert; end
7124
7475
  end
7125
7476
 
@@ -7135,12 +7486,19 @@ end
7135
7486
  class Arel::Nodes::Lateral < ::Arel::Nodes::Unary
7136
7487
  end
7137
7488
 
7489
+ class Arel::Nodes::LeadingJoin < ::Arel::Nodes::InnerJoin
7490
+ end
7491
+
7138
7492
  class Arel::Nodes::LessThan < ::Arel::Nodes::Binary
7139
7493
  include(::Arel::Nodes::FetchAttribute)
7494
+
7495
+ def invert; end
7140
7496
  end
7141
7497
 
7142
7498
  class Arel::Nodes::LessThanOrEqual < ::Arel::Nodes::Binary
7143
7499
  include(::Arel::Nodes::FetchAttribute)
7500
+
7501
+ def invert; end
7144
7502
  end
7145
7503
 
7146
7504
  class Arel::Nodes::Limit < ::Arel::Nodes::Unary
@@ -7153,7 +7511,7 @@ class Arel::Nodes::Matches < ::Arel::Nodes::Binary
7153
7511
  def initialize(left, right, escape = T.unsafe(nil), case_sensitive = T.unsafe(nil)); end
7154
7512
 
7155
7513
  def case_sensitive; end
7156
- def case_sensitive=(_); end
7514
+ def case_sensitive=(_arg0); end
7157
7515
  def escape; end
7158
7516
  end
7159
7517
 
@@ -7174,7 +7532,7 @@ class Arel::Nodes::NamedFunction < ::Arel::Nodes::Function
7174
7532
  def eql?(other); end
7175
7533
  def hash; end
7176
7534
  def name; end
7177
- def name=(_); end
7535
+ def name=(_arg0); end
7178
7536
  end
7179
7537
 
7180
7538
  class Arel::Nodes::NamedWindow < ::Arel::Nodes::Window
@@ -7184,7 +7542,7 @@ class Arel::Nodes::NamedWindow < ::Arel::Nodes::Window
7184
7542
  def eql?(other); end
7185
7543
  def hash; end
7186
7544
  def name; end
7187
- def name=(_); end
7545
+ def name=(_arg0); end
7188
7546
 
7189
7547
  private
7190
7548
 
@@ -7216,19 +7574,25 @@ end
7216
7574
 
7217
7575
  class Arel::Nodes::NotEqual < ::Arel::Nodes::Binary
7218
7576
  include(::Arel::Nodes::FetchAttribute)
7577
+
7578
+ def invert; end
7219
7579
  end
7220
7580
 
7221
7581
  class Arel::Nodes::NotIn < ::Arel::Nodes::Binary
7222
7582
  include(::Arel::Nodes::FetchAttribute)
7583
+
7584
+ def invert; end
7223
7585
  end
7224
7586
 
7225
7587
  class Arel::Nodes::NotRegexp < ::Arel::Nodes::Regexp
7226
7588
  end
7227
7589
 
7228
7590
  class Arel::Nodes::NullsFirst < ::Arel::Nodes::Ordering
7591
+ def reverse; end
7229
7592
  end
7230
7593
 
7231
7594
  class Arel::Nodes::NullsLast < ::Arel::Nodes::Ordering
7595
+ def reverse; end
7232
7596
  end
7233
7597
 
7234
7598
  class Arel::Nodes::Offset < ::Arel::Nodes::Unary
@@ -7258,6 +7622,10 @@ class Arel::Nodes::Over < ::Arel::Nodes::Binary
7258
7622
  def operator; end
7259
7623
  end
7260
7624
 
7625
+ class Arel::Nodes::Overlaps < ::Arel::Nodes::InfixOperation
7626
+ def initialize(left, right); end
7627
+ end
7628
+
7261
7629
  class Arel::Nodes::Preceding < ::Arel::Nodes::Unary
7262
7630
  def initialize(expr = T.unsafe(nil)); end
7263
7631
  end
@@ -7277,7 +7645,7 @@ class Arel::Nodes::Regexp < ::Arel::Nodes::Binary
7277
7645
  def initialize(left, right, case_sensitive = T.unsafe(nil)); end
7278
7646
 
7279
7647
  def case_sensitive; end
7280
- def case_sensitive=(_); end
7648
+ def case_sensitive=(_arg0); end
7281
7649
  end
7282
7650
 
7283
7651
  class Arel::Nodes::RightOuterJoin < ::Arel::Nodes::Join
@@ -7291,33 +7659,33 @@ class Arel::Nodes::Rows < ::Arel::Nodes::Unary
7291
7659
  end
7292
7660
 
7293
7661
  class Arel::Nodes::SelectCore < ::Arel::Nodes::Node
7294
- def initialize; end
7662
+ def initialize(relation = T.unsafe(nil)); end
7295
7663
 
7296
7664
  def ==(other); end
7297
7665
  def comment; end
7298
- def comment=(_); end
7666
+ def comment=(_arg0); end
7299
7667
  def eql?(other); end
7300
7668
  def from; end
7301
7669
  def from=(value); end
7302
7670
  def froms; end
7303
7671
  def froms=(value); end
7304
7672
  def groups; end
7305
- def groups=(_); end
7673
+ def groups=(_arg0); end
7306
7674
  def hash; end
7307
7675
  def havings; end
7308
- def havings=(_); end
7676
+ def havings=(_arg0); end
7309
7677
  def optimizer_hints; end
7310
- def optimizer_hints=(_); end
7678
+ def optimizer_hints=(_arg0); end
7311
7679
  def projections; end
7312
- def projections=(_); end
7680
+ def projections=(_arg0); end
7313
7681
  def set_quantifier; end
7314
- def set_quantifier=(_); end
7682
+ def set_quantifier=(_arg0); end
7315
7683
  def source; end
7316
- def source=(_); end
7684
+ def source=(_arg0); end
7317
7685
  def wheres; end
7318
- def wheres=(_); end
7686
+ def wheres=(_arg0); end
7319
7687
  def windows; end
7320
- def windows=(_); end
7688
+ def windows=(_arg0); end
7321
7689
 
7322
7690
  private
7323
7691
 
@@ -7325,22 +7693,22 @@ class Arel::Nodes::SelectCore < ::Arel::Nodes::Node
7325
7693
  end
7326
7694
 
7327
7695
  class Arel::Nodes::SelectStatement < ::Arel::Nodes::NodeExpression
7328
- def initialize(cores = T.unsafe(nil)); end
7696
+ def initialize(relation = T.unsafe(nil)); end
7329
7697
 
7330
7698
  def ==(other); end
7331
7699
  def cores; end
7332
7700
  def eql?(other); end
7333
7701
  def hash; end
7334
7702
  def limit; end
7335
- def limit=(_); end
7703
+ def limit=(_arg0); end
7336
7704
  def lock; end
7337
- def lock=(_); end
7705
+ def lock=(_arg0); end
7338
7706
  def offset; end
7339
- def offset=(_); end
7707
+ def offset=(_arg0); end
7340
7708
  def orders; end
7341
- def orders=(_); end
7709
+ def orders=(_arg0); end
7342
7710
  def with; end
7343
- def with=(_); end
7711
+ def with=(_arg0); end
7344
7712
 
7345
7713
  private
7346
7714
 
@@ -7375,7 +7743,7 @@ class Arel::Nodes::TableAlias < ::Arel::Nodes::Binary
7375
7743
  def relation; end
7376
7744
  def table_alias; end
7377
7745
  def table_name; end
7378
- def type_cast_for_database(*args); end
7746
+ def type_cast_for_database(attr_name, value); end
7379
7747
  def type_for_attribute(name); end
7380
7748
  end
7381
7749
 
@@ -7391,7 +7759,7 @@ class Arel::Nodes::Unary < ::Arel::Nodes::NodeExpression
7391
7759
  def ==(other); end
7392
7760
  def eql?(other); end
7393
7761
  def expr; end
7394
- def expr=(_); end
7762
+ def expr=(_arg0); end
7395
7763
  def hash; end
7396
7764
  def value; end
7397
7765
  end
@@ -7410,32 +7778,32 @@ end
7410
7778
 
7411
7779
  class Arel::Nodes::UnqualifiedColumn < ::Arel::Nodes::Unary
7412
7780
  def attribute; end
7413
- def attribute=(_); end
7781
+ def attribute=(_arg0); end
7414
7782
  def column; end
7415
7783
  def name; end
7416
7784
  def relation; end
7417
7785
  end
7418
7786
 
7419
7787
  class Arel::Nodes::UpdateStatement < ::Arel::Nodes::Node
7420
- def initialize; end
7788
+ def initialize(relation = T.unsafe(nil)); end
7421
7789
 
7422
7790
  def ==(other); end
7423
7791
  def eql?(other); end
7424
7792
  def hash; end
7425
7793
  def key; end
7426
- def key=(_); end
7794
+ def key=(_arg0); end
7427
7795
  def limit; end
7428
- def limit=(_); end
7796
+ def limit=(_arg0); end
7429
7797
  def offset; end
7430
- def offset=(_); end
7798
+ def offset=(_arg0); end
7431
7799
  def orders; end
7432
- def orders=(_); end
7800
+ def orders=(_arg0); end
7433
7801
  def relation; end
7434
- def relation=(_); end
7802
+ def relation=(_arg0); end
7435
7803
  def values; end
7436
- def values=(_); end
7804
+ def values=(_arg0); end
7437
7805
  def wheres; end
7438
- def wheres=(_); end
7806
+ def wheres=(_arg0); end
7439
7807
 
7440
7808
  private
7441
7809
 
@@ -7456,14 +7824,14 @@ class Arel::Nodes::Window < ::Arel::Nodes::Node
7456
7824
  def eql?(other); end
7457
7825
  def frame(expr); end
7458
7826
  def framing; end
7459
- def framing=(_); end
7827
+ def framing=(_arg0); end
7460
7828
  def hash; end
7461
7829
  def order(*expr); end
7462
7830
  def orders; end
7463
- def orders=(_); end
7831
+ def orders=(_arg0); end
7464
7832
  def partition(*expr); end
7465
7833
  def partitions; end
7466
- def partitions=(_); end
7834
+ def partitions=(_arg0); end
7467
7835
  def range(expr = T.unsafe(nil)); end
7468
7836
  def rows(expr = T.unsafe(nil)); end
7469
7837
 
@@ -7487,6 +7855,7 @@ end
7487
7855
  module Arel::Predications
7488
7856
  def between(other); end
7489
7857
  def concat(other); end
7858
+ def contains(other); end
7490
7859
  def does_not_match(other, escape = T.unsafe(nil), case_sensitive = T.unsafe(nil)); end
7491
7860
  def does_not_match_all(others, escape = T.unsafe(nil)); end
7492
7861
  def does_not_match_any(others, escape = T.unsafe(nil)); end
@@ -7522,6 +7891,8 @@ module Arel::Predications
7522
7891
  def not_in(other); end
7523
7892
  def not_in_all(others); end
7524
7893
  def not_in_any(others); end
7894
+ def overlaps(other); end
7895
+ def quoted_array(others); end
7525
7896
  def when(right); end
7526
7897
 
7527
7898
  private
@@ -7530,7 +7901,6 @@ module Arel::Predications
7530
7901
  def grouping_any(method_id, others, *extras); end
7531
7902
  def infinity?(value); end
7532
7903
  def open_ended?(value); end
7533
- def quoted_array(others); end
7534
7904
  def quoted_node(other); end
7535
7905
  def unboundable?(value); end
7536
7906
  end
@@ -7575,6 +7945,7 @@ class Arel::SelectManager < ::Arel::TreeManager
7575
7945
  def take(limit); end
7576
7946
  def taken; end
7577
7947
  def union(operation, other = T.unsafe(nil)); end
7948
+ def where(expr); end
7578
7949
  def where_sql(engine = T.unsafe(nil)); end
7579
7950
  def window(name); end
7580
7951
  def with(*subqueries); end
@@ -7588,13 +7959,13 @@ end
7588
7959
  Arel::SelectManager::STRING_OR_SYMBOL_CLASS = T.let(T.unsafe(nil), Array)
7589
7960
 
7590
7961
  class Arel::Table
7591
- include(::Arel::Crud)
7592
7962
  include(::Arel::FactoryMethods)
7963
+ include(::Arel::AliasPredication)
7593
7964
 
7594
- def initialize(name, as: T.unsafe(nil), type_caster: T.unsafe(nil)); end
7965
+ def initialize(name, as: T.unsafe(nil), klass: T.unsafe(nil), type_caster: T.unsafe(nil)); end
7595
7966
 
7596
7967
  def ==(other); end
7597
- def [](name); end
7968
+ def [](name, table = T.unsafe(nil)); end
7598
7969
  def able_to_type_cast?; end
7599
7970
  def alias(name = T.unsafe(nil)); end
7600
7971
  def eql?(other); end
@@ -7604,16 +7975,16 @@ class Arel::Table
7604
7975
  def having(expr); end
7605
7976
  def join(relation, klass = T.unsafe(nil)); end
7606
7977
  def name; end
7607
- def name=(_); end
7978
+ def name=(_arg0); end
7608
7979
  def order(*expr); end
7609
7980
  def outer_join(relation); end
7610
7981
  def project(*things); end
7611
7982
  def skip(amount); end
7612
7983
  def table_alias; end
7613
- def table_alias=(_); end
7984
+ def table_alias=(_arg0); end
7614
7985
  def table_name; end
7615
7986
  def take(amount); end
7616
- def type_cast_for_database(attribute_name, value); end
7987
+ def type_cast_for_database(attr_name, value); end
7617
7988
  def type_for_attribute(name); end
7618
7989
  def where(condition); end
7619
7990
 
@@ -7623,19 +7994,16 @@ class Arel::Table
7623
7994
 
7624
7995
  class << self
7625
7996
  def engine; end
7626
- def engine=(_); end
7997
+ def engine=(_arg0); end
7627
7998
  end
7628
7999
  end
7629
8000
 
7630
8001
  class Arel::TreeManager
7631
8002
  include(::Arel::FactoryMethods)
7632
8003
 
7633
- def initialize; end
7634
-
7635
8004
  def ast; end
7636
8005
  def to_dot; end
7637
8006
  def to_sql(engine = T.unsafe(nil)); end
7638
- def where(expr); end
7639
8007
 
7640
8008
  private
7641
8009
 
@@ -7655,7 +8023,7 @@ end
7655
8023
  class Arel::UpdateManager < ::Arel::TreeManager
7656
8024
  include(::Arel::TreeManager::StatementMethods)
7657
8025
 
7658
- def initialize; end
8026
+ def initialize(table = T.unsafe(nil)); end
7659
8027
 
7660
8028
  def set(values); end
7661
8029
  def table(table); end
@@ -7684,13 +8052,7 @@ class Arel::Visitors::Dot < ::Arel::Visitors::Visitor
7684
8052
  def unary(o); end
7685
8053
  def visit(o); end
7686
8054
  def visit_ActiveModel_Attribute(o); end
7687
- def visit_Arel_Attribute(o); end
7688
8055
  def visit_Arel_Attributes_Attribute(o); end
7689
- def visit_Arel_Attributes_Boolean(o); end
7690
- def visit_Arel_Attributes_Float(o); end
7691
- def visit_Arel_Attributes_Integer(o); end
7692
- def visit_Arel_Attributes_String(o); end
7693
- def visit_Arel_Attributes_Time(o); end
7694
8056
  def visit_Arel_Nodes_And(o); end
7695
8057
  def visit_Arel_Nodes_As(o); end
7696
8058
  def visit_Arel_Nodes_Assignment(o); end
@@ -7783,11 +8145,11 @@ class Arel::Visitors::Dot::Node
7783
8145
  def initialize(name, id, fields = T.unsafe(nil)); end
7784
8146
 
7785
8147
  def fields; end
7786
- def fields=(_); end
8148
+ def fields=(_arg0); end
7787
8149
  def id; end
7788
- def id=(_); end
8150
+ def id=(_arg0); end
7789
8151
  def name; end
7790
- def name=(_); end
8152
+ def name=(_arg0); end
7791
8153
  end
7792
8154
 
7793
8155
  class Arel::Visitors::MySQL < ::Arel::Visitors::ToSql
@@ -7812,9 +8174,9 @@ class Arel::Visitors::PostgreSQL < ::Arel::Visitors::ToSql
7812
8174
 
7813
8175
  private
7814
8176
 
8177
+ def bind_block; end
7815
8178
  def grouping_array_or_grouping_element(o, collector); end
7816
8179
  def grouping_parentheses(o, collector); end
7817
- def visit_Arel_Nodes_BindParam(o, collector); end
7818
8180
  def visit_Arel_Nodes_Cube(o, collector); end
7819
8181
  def visit_Arel_Nodes_DistinctOn(o, collector); end
7820
8182
  def visit_Arel_Nodes_DoesNotMatch(o, collector); end
@@ -7851,7 +8213,9 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
7851
8213
  private
7852
8214
 
7853
8215
  def aggregate(name, o, collector); end
8216
+ def bind_block; end
7854
8217
  def build_subselect(key, o); end
8218
+ def collect_ctes(children, collector); end
7855
8219
  def collect_nodes_for(nodes, collector, spacer, connector = T.unsafe(nil)); end
7856
8220
  def collect_optimizer_hints(o, collector); end
7857
8221
  def has_join_sources?(o); end
@@ -7869,10 +8233,10 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
7869
8233
  def sanitize_as_sql_comment(value); end
7870
8234
  def unboundable?(value); end
7871
8235
  def unsupported(o, collector); end
8236
+ def visit_ActiveModel_Attribute(o, collector); end
7872
8237
  def visit_ActiveSupport_Multibyte_Chars(o, collector); end
7873
8238
  def visit_ActiveSupport_StringInquirer(o, collector); end
7874
8239
  def visit_Arel_Attributes_Attribute(o, collector); end
7875
- def visit_Arel_Nodes_Addition(o, collector); end
7876
8240
  def visit_Arel_Nodes_And(o, collector); end
7877
8241
  def visit_Arel_Nodes_As(o, collector); end
7878
8242
  def visit_Arel_Nodes_Ascending(o, collector); end
@@ -7890,7 +8254,6 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
7890
8254
  def visit_Arel_Nodes_Descending(o, collector); end
7891
8255
  def visit_Arel_Nodes_Distinct(o, collector); end
7892
8256
  def visit_Arel_Nodes_DistinctOn(o, collector); end
7893
- def visit_Arel_Nodes_Division(o, collector); end
7894
8257
  def visit_Arel_Nodes_DoesNotMatch(o, collector); end
7895
8258
  def visit_Arel_Nodes_Else(o, collector); end
7896
8259
  def visit_Arel_Nodes_Equality(o, collector); end
@@ -7920,7 +8283,6 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
7920
8283
  def visit_Arel_Nodes_Matches(o, collector); end
7921
8284
  def visit_Arel_Nodes_Max(o, collector); end
7922
8285
  def visit_Arel_Nodes_Min(o, collector); end
7923
- def visit_Arel_Nodes_Multiplication(o, collector); end
7924
8286
  def visit_Arel_Nodes_NamedFunction(o, collector); end
7925
8287
  def visit_Arel_Nodes_NamedWindow(o, collector); end
7926
8288
  def visit_Arel_Nodes_Not(o, collector); end
@@ -7944,7 +8306,6 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
7944
8306
  def visit_Arel_Nodes_SelectStatement(o, collector); end
7945
8307
  def visit_Arel_Nodes_SqlLiteral(o, collector); end
7946
8308
  def visit_Arel_Nodes_StringJoin(o, collector); end
7947
- def visit_Arel_Nodes_Subtraction(o, collector); end
7948
8309
  def visit_Arel_Nodes_Sum(o, collector); end
7949
8310
  def visit_Arel_Nodes_TableAlias(o, collector); end
7950
8311
  def visit_Arel_Nodes_True(o, collector); end
@@ -7997,15 +8358,6 @@ class Arel::Visitors::Visitor
7997
8358
  end
7998
8359
  end
7999
8360
 
8000
- class Arel::Visitors::WhereSql < ::Arel::Visitors::ToSql
8001
- def initialize(inner_visitor, *args, &block); end
8002
-
8003
-
8004
- private
8005
-
8006
- def visit_Arel_Nodes_SelectCore(o, collector); end
8007
- end
8008
-
8009
8361
  module Arel::WindowPredications
8010
8362
  def over(expr = T.unsafe(nil)); end
8011
8363
  end