sorbet-result 1.2.0 → 1.3.0

data/sorbet/rbi/gems/{json@2.7.5.rbi → json@2.12.2.rbi}

@@ -5,19 +5,26 @@
 # Please instead update this file by running `bin/tapioca gem json`.
 
 
-# Extends any Class to include _json_creatable?_ method.
-#
-# source://json//lib/json/common.rb#726
-class Class < ::Module
-  # Returns true if this class can be used to create an instance
-  # from a serialised JSON string. The class has to implement a class
-  # method _json_create_ that expects a hash as first parameter. The hash
-  # should include the required data.
-  #
-  # @return [Boolean]
-  #
-  # source://json//lib/json/common.rb#731
-  def json_creatable?; end
+class Array
+  include ::Enumerable
+  include ::JSON::Ext::Generator::GeneratorMethods::Array
+end
+
+class FalseClass
+  include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
+end
+
+class Float < ::Numeric
+  include ::JSON::Ext::Generator::GeneratorMethods::Float
+end
+
+class Hash
+  include ::Enumerable
+  include ::JSON::Ext::Generator::GeneratorMethods::Hash
+end
+
+class Integer < ::Numeric
+  include ::JSON::Ext::Generator::GeneratorMethods::Integer
 end
 
 # = JavaScript \Object Notation (\JSON)
@@ -396,13 +403,13 @@ end
 #   json1 = JSON.generate(ruby)
 #   ruby1 = JSON.parse(json1, create_additions: true)
 #   # Make a nice display.
-#   display = <<EOT
-#   Generated JSON:
-#     Without addition:  #{json0} (#{json0.class})
-#     With addition:     #{json1} (#{json1.class})
-#   Parsed JSON:
-#     Without addition:  #{ruby0.inspect} (#{ruby0.class})
-#     With addition:     #{ruby1.inspect} (#{ruby1.class})
+#   display = <<~EOT
+#     Generated JSON:
+#       Without addition:  #{json0} (#{json0.class})
+#       With addition:     #{json1} (#{json1.class})
+#     Parsed JSON:
+#       Without addition:  #{ruby0.inspect} (#{ruby0.class})
+#       With addition:     #{ruby1.inspect} (#{ruby1.class})
 #   EOT
 #   puts display
 #
@@ -580,13 +587,13 @@ end
 #   json1 = JSON.generate(foo1)
 #   obj1 = JSON.parse(json1, create_additions: true)
 #   #   Make a nice display.
-#   display = <<EOT
-#   Generated JSON:
-#     Without custom addition:  #{json0} (#{json0.class})
-#     With custom addition:     #{json1} (#{json1.class})
-#   Parsed JSON:
-#     Without custom addition:  #{obj0.inspect} (#{obj0.class})
-#     With custom addition:     #{obj1.inspect} (#{obj1.class})
+#   display = <<~EOT
+#     Generated JSON:
+#       Without custom addition:  #{json0} (#{json0.class})
+#       With custom addition:     #{json1} (#{json1.class})
+#     Parsed JSON:
+#       Without custom addition:  #{obj0.inspect} (#{obj0.class})
+#       With custom addition:     #{obj1.inspect} (#{obj1.class})
 #   EOT
 #   puts display
 #
@@ -631,7 +638,7 @@ module JSON
   # Output:
   #   {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"}
   #
-  # source://json//lib/json/common.rb#630
+  # source://json//lib/json/common.rb#892
   def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil), kwargs = T.unsafe(nil)); end
 
   # :call-seq:
@@ -648,14 +655,11 @@ module JSON
   #   # Raises SystemStackError (stack level too deep):
   #   JSON.fast_generate(a)
   #
-  # source://json//lib/json/common.rb#337
+  # source://json//lib/json/common.rb#445
   def fast_generate(obj, opts = T.unsafe(nil)); end
 
-  # :stopdoc:
-  # I want to deprecate these later, so I'll first be silent about them, and later delete them.
-  #
-  # source://json//lib/json/common.rb#337
-  def fast_unparse(obj, opts = T.unsafe(nil)); end
+  # source://json//lib/json/common.rb#937
+  def fast_unparse(*_arg0, **_arg1, &_arg2); end
 
   # :call-seq:
   #   JSON.generate(obj, opts = nil) -> new_string
@@ -693,7 +697,7 @@ module JSON
   #   # Raises JSON::NestingError (nesting of 100 is too deep):
   #   JSON.generate(a)
   #
-  # source://json//lib/json/common.rb#308
+  # source://json//lib/json/common.rb#424
   def generate(obj, opts = T.unsafe(nil)); end
 
   # :call-seq:
@@ -701,6 +705,16 @@ module JSON
   #
   # Returns the Ruby objects created by parsing the given +source+.
   #
+  # BEWARE: This method is meant to serialise data from trusted user input,
+  # like from your own database server or clients under your control, it could
+  # be dangerous to allow untrusted users to pass JSON sources into it.
+  # If you must use it, use JSON.unsafe_load instead to make it clear.
+  #
+  # Since JSON version 2.8.0, `load` emits a deprecation warning when a
+  # non native type is deserialized, without `create_additions` being explicitly
+  # enabled, and in JSON version 3.0, `load` will have `create_additions` disabled
+  # by default.
+  #
   # - Argument +source+ must be, or be convertible to, a \String:
   #   - If +source+ responds to instance method +to_str+,
   #     <tt>source.to_str</tt> becomes the source.
@@ -715,9 +729,6 @@ module JSON
   # - Argument +proc+, if given, must be a \Proc that accepts one argument.
   #   It will be called recursively with each result (depth-first order).
   #   See details below.
-  #   BEWARE: This method is meant to serialise data from trusted user input,
-  #   like from your own database server or clients under your control, it could
-  #   be dangerous to allow untrusted users to pass JSON sources into it.
   # - Argument +opts+, if given, contains a \Hash of options for the parsing.
   #   See {Parsing Options}[#module-JSON-label-Parsing+Options].
   #   The default options can be changed via method JSON.load_default_options=.
@@ -728,17 +739,17 @@ module JSON
   # <tt>parse(source, opts)</tt>;  see #parse.
   #
   # Source for following examples:
-  #   source = <<-EOT
-  #   {
-  #   "name": "Dave",
-  #     "age" :40,
-  #     "hats": [
-  #       "Cattleman's",
-  #       "Panama",
-  #       "Tophat"
-  #     ]
-  #   }
-  #   EOT
+  #   source = <<~JSON
+  #     {
+  #       "name": "Dave",
+  #       "age" :40,
+  #       "hats": [
+  #         "Cattleman's",
+  #         "Panama",
+  #         "Tophat"
+  #       ]
+  #     }
+  #   JSON
   #
   # Load a \String:
   #   ruby = JSON.load(source)
@@ -824,7 +835,7 @@ module JSON
   #      #<Admin:0x00000000064c41f8
   #      @attributes={"type"=>"Admin", "password"=>"0wn3d"}>}
   #
-  # source://json//lib/json/common.rb#549
+  # source://json//lib/json/common.rb#826
   def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
 
   # :call-seq:
@@ -835,7 +846,7 @@ module JSON
   #
   # See method #parse.
   #
-  # source://json//lib/json/common.rb#257
+  # source://json//lib/json/common.rb#373
   def load_file(filespec, opts = T.unsafe(nil)); end
 
   # :call-seq:
@@ -846,12 +857,9 @@ module JSON
   #
   # See method #parse!
   #
-  # source://json//lib/json/common.rb#268
+  # source://json//lib/json/common.rb#384
   def load_file!(filespec, opts = T.unsafe(nil)); end
 
-  # source://json//lib/json/common.rb#674
-  def merge_dump_options(opts, strict: T.unsafe(nil)); end
-
   # :call-seq:
   #   JSON.parse(source, opts) -> object
   #
@@ -880,17 +888,17 @@ module JSON
   # {Parsing \JSON}[#module-JSON-label-Parsing+JSON].
   #
   # Parses nested JSON objects:
-  #   source = <<-EOT
-  #   {
-  #   "name": "Dave",
-  #     "age" :40,
-  #     "hats": [
-  #       "Cattleman's",
-  #       "Panama",
-  #       "Tophat"
-  #     ]
-  #   }
-  #   EOT
+  #   source = <<~JSON
+  #     {
+  #     "name": "Dave",
+  #       "age" :40,
+  #       "hats": [
+  #         "Cattleman's",
+  #         "Panama",
+  #         "Tophat"
+  #       ]
+  #     }
+  #   JSON
   #   ruby = JSON.parse(source)
   #   ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
   #
@@ -900,7 +908,7 @@ module JSON
   #   # Raises JSON::ParserError (783: unexpected token at ''):
   #   JSON.parse('')
   #
-  # source://json//lib/json/common.rb#218
+  # source://json//lib/json/common.rb#336
   def parse(source, opts = T.unsafe(nil)); end
 
   # :call-seq:
@@ -915,7 +923,7 @@ module JSON
   #   which disables checking for nesting depth.
   # - Option +allow_nan+, if not provided, defaults to +true+.
   #
-  # source://json//lib/json/common.rb#242
+  # source://json//lib/json/common.rb#358
   def parse!(source, opts = T.unsafe(nil)); end
 
   # :call-seq:
@@ -948,29 +956,153 @@ module JSON
   #     }
   #   }
   #
-  # source://json//lib/json/common.rb#382
+  # source://json//lib/json/common.rb#492
   def pretty_generate(obj, opts = T.unsafe(nil)); end
 
+  # source://json//lib/json/common.rb#947
+  def pretty_unparse(*_arg0, **_arg1, &_arg2); end
+
+  # source://json//lib/json/common.rb#957
+  def restore(*_arg0, **_arg1, &_arg2); end
+
   # :stopdoc:
-  # I want to deprecate these later, so I'll first be silent about them, and later delete them.
+  # All these were meant to be deprecated circa 2009, but were just set as undocumented
+  # so usage still exist in the wild.
   #
-  # source://json//lib/json/common.rb#382
-  def pretty_unparse(obj, opts = T.unsafe(nil)); end
+  # source://json//lib/json/common.rb#927
+  def unparse(*_arg0, **_arg1, &_arg2); end
 
-  # Recursively calls passed _Proc_ if the parsed data structure is an _Array_ or _Hash_
+  # :call-seq:
+  #   JSON.unsafe_load(source, proc = nil, options = {}) -> object
   #
-  # source://json//lib/json/common.rb#575
-  def recurse_proc(result, &proc); end
-
-  # source://json//lib/json/common.rb#549
-  def restore(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  # :stopdoc:
-  # I want to deprecate these later, so I'll first be silent about them, and
-  # later delete them.
+  # Returns the Ruby objects created by parsing the given +source+.
+  #
+  # BEWARE: This method is meant to serialise data from trusted user input,
+  # like from your own database server or clients under your control, it could
+  # be dangerous to allow untrusted users to pass JSON sources into it.
+  #
+  # - Argument +source+ must be, or be convertible to, a \String:
+  #   - If +source+ responds to instance method +to_str+,
+  #     <tt>source.to_str</tt> becomes the source.
+  #   - If +source+ responds to instance method +to_io+,
+  #     <tt>source.to_io.read</tt> becomes the source.
+  #   - If +source+ responds to instance method +read+,
+  #     <tt>source.read</tt> becomes the source.
+  #   - If both of the following are true, source becomes the \String <tt>'null'</tt>:
+  #     - Option +allow_blank+ specifies a truthy value.
+  #     - The source, as defined above, is +nil+ or the empty \String <tt>''</tt>.
+  #   - Otherwise, +source+ remains the source.
+  # - Argument +proc+, if given, must be a \Proc that accepts one argument.
+  #   It will be called recursively with each result (depth-first order).
+  #   See details below.
+  # - Argument +opts+, if given, contains a \Hash of options for the parsing.
+  #   See {Parsing Options}[#module-JSON-label-Parsing+Options].
+  #   The default options can be changed via method JSON.unsafe_load_default_options=.
+  #
+  # ---
+  #
+  # When no +proc+ is given, modifies +source+ as above and returns the result of
+  # <tt>parse(source, opts)</tt>;  see #parse.
+  #
+  # Source for following examples:
+  #   source = <<~JSON
+  #     {
+  #       "name": "Dave",
+  #       "age" :40,
+  #       "hats": [
+  #         "Cattleman's",
+  #         "Panama",
+  #         "Tophat"
+  #       ]
+  #     }
+  #   JSON
+  #
+  # Load a \String:
+  #   ruby = JSON.unsafe_load(source)
+  #   ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
+  #
+  # Load an \IO object:
+  #   require 'stringio'
+  #   object = JSON.unsafe_load(StringIO.new(source))
+  #   object # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
+  #
+  # Load a \File object:
+  #   path = 't.json'
+  #   File.write(path, source)
+  #   File.open(path) do |file|
+  #     JSON.unsafe_load(file)
+  #   end # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
+  #
+  # ---
+  #
+  # When +proc+ is given:
+  # - Modifies +source+ as above.
+  # - Gets the +result+ from calling <tt>parse(source, opts)</tt>.
+  # - Recursively calls <tt>proc(result)</tt>.
+  # - Returns the final result.
+  #
+  # Example:
+  #   require 'json'
+  #
+  #   # Some classes for the example.
+  #   class Base
+  #     def initialize(attributes)
+  #       @attributes = attributes
+  #     end
+  #   end
+  #   class User    < Base; end
+  #   class Account < Base; end
+  #   class Admin   < Base; end
+  #   # The JSON source.
+  #   json = <<-EOF
+  #   {
+  #     "users": [
+  #         {"type": "User", "username": "jane", "email": "jane@example.com"},
+  #         {"type": "User", "username": "john", "email": "john@example.com"}
+  #     ],
+  #     "accounts": [
+  #         {"account": {"type": "Account", "paid": true, "account_id": "1234"}},
+  #         {"account": {"type": "Account", "paid": false, "account_id": "1235"}}
+  #     ],
+  #     "admins": {"type": "Admin", "password": "0wn3d"}
+  #   }
+  #   EOF
+  #   # Deserializer method.
+  #   def deserialize_obj(obj, safe_types = %w(User Account Admin))
+  #     type = obj.is_a?(Hash) && obj["type"]
+  #     safe_types.include?(type) ? Object.const_get(type).new(obj) : obj
+  #   end
+  #   # Call to JSON.unsafe_load
+  #   ruby = JSON.unsafe_load(json, proc {|obj|
+  #     case obj
+  #     when Hash
+  #       obj.each {|k, v| obj[k] = deserialize_obj v }
+  #     when Array
+  #       obj.map! {|v| deserialize_obj v }
+  #     end
+  #   })
+  #   pp ruby
+  # Output:
+  #   {"users"=>
+  #      [#<User:0x00000000064c4c98
+  #        @attributes=
+  #          {"type"=>"User", "username"=>"jane", "email"=>"jane@example.com"}>,
+  #        #<User:0x00000000064c4bd0
+  #        @attributes=
+  #          {"type"=>"User", "username"=>"john", "email"=>"john@example.com"}>],
+  #    "accounts"=>
+  #      [{"account"=>
+  #          #<Account:0x00000000064c4928
+  #          @attributes={"type"=>"Account", "paid"=>true, "account_id"=>"1234"}>},
+  #       {"account"=>
+  #          #<Account:0x00000000064c4680
+  #          @attributes={"type"=>"Account", "paid"=>false, "account_id"=>"1235"}>}],
+  #    "admins"=>
+  #      #<Admin:0x00000000064c41f8
+  #      @attributes={"type"=>"Admin", "password"=>"0wn3d"}>}
   #
-  # source://json//lib/json/common.rb#308
-  def unparse(obj, opts = T.unsafe(nil)); end
+  # source://json//lib/json/common.rb#666
+  def unsafe_load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
 
   class << self
     # :call-seq:
@@ -985,34 +1117,28 @@ module JSON
     #   ruby = [0, 1, nil]
     #   JSON[ruby] # => '[0,1,null]'
     #
-    # source://json//lib/json/common.rb#22
+    # source://json//lib/json/common.rb#126
     def [](object, opts = T.unsafe(nil)); end
 
-    # source://json//lib/json/common.rb#90
-    def create_fast_state; end
-
     # Returns the current create identifier.
     # See also JSON.create_id=.
     #
-    # source://json//lib/json/common.rb#129
+    # source://json//lib/json/common.rb#219
     def create_id; end
 
     # Sets create identifier, which is used to decide if the _json_create_
     # hook of a class should be called; initial value is +json_class+:
     #   JSON.create_id # => 'json_class'
     #
-    # source://json//lib/json/common.rb#123
+    # source://json//lib/json/common.rb#213
     def create_id=(new_value); end
 
-    # source://json//lib/json/common.rb#100
-    def create_pretty_state; end
-
     # Return the constant located at _path_. The format of _path_ has to be
     # either ::A::B::C or A::B::C. In any case, A has to be located at the top
     # level (absolute namespace path?). If there doesn't exist a constant at
     # the given path, an ArgumentError is raised.
     #
-    # source://json//lib/json/common.rb#51
+    # source://json//lib/json/common.rb#153
     def deep_const_get(path); end
 
     # :call-seq:
@@ -1043,25 +1169,9 @@ module JSON
     # Output:
     #   {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"}
     #
-    # source://json//lib/json/common.rb#630
+    # source://json//lib/json/common.rb#892
     def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil), kwargs = T.unsafe(nil)); end
 
-    # Sets or returns the default options for the JSON.dump method.
-    # Initially:
-    #   opts = JSON.dump_default_options
-    #   opts # => {:max_nesting=>false, :allow_nan=>true}
-    #
-    # source://json//lib/json/common.rb#596
-    def dump_default_options; end
-
-    # Sets or returns the default options for the JSON.dump method.
-    # Initially:
-    #   opts = JSON.dump_default_options
-    #   opts # => {:max_nesting=>false, :allow_nan=>true}
-    #
-    # source://json//lib/json/common.rb#596
-    def dump_default_options=(_arg0); end
-
     # :call-seq:
     #   JSON.fast_generate(obj, opts) -> new_string
     #
@@ -1076,14 +1186,11 @@ module JSON
     #   # Raises SystemStackError (stack level too deep):
     #   JSON.fast_generate(a)
     #
-    # source://json//lib/json/common.rb#337
+    # source://json//lib/json/common.rb#445
     def fast_generate(obj, opts = T.unsafe(nil)); end
 
-    # :stopdoc:
-    # I want to deprecate these later, so I'll first be silent about them, and later delete them.
-    #
-    # source://json//lib/json/common.rb#337
-    def fast_unparse(obj, opts = T.unsafe(nil)); end
+    # source://json//lib/json/common.rb#937
+    def fast_unparse(*_arg0, **_arg1, &_arg2); end
 
     # :call-seq:
     #   JSON.generate(obj, opts = nil) -> new_string
@@ -1121,31 +1228,34 @@ module JSON
     #   # Raises JSON::NestingError (nesting of 100 is too deep):
     #   JSON.generate(a)
     #
-    # source://json//lib/json/common.rb#308
+    # source://json//lib/json/common.rb#424
     def generate(obj, opts = T.unsafe(nil)); end
 
-    # Returns the JSON generator module that is used by JSON. This is
-    # either JSON::Ext::Generator or JSON::Pure::Generator:
-    #   JSON.generator # => JSON::Ext::Generator
+    # Returns the JSON generator module that is used by JSON.
     #
-    # source://json//lib/json/common.rb#112
+    # source://json//lib/json/common.rb#181
     def generator; end
 
     # Set the module _generator_ to be used by JSON.
     #
-    # source://json//lib/json/common.rb#67
+    # source://json//lib/json/common.rb#160
     def generator=(generator); end
 
-    # Encodes string using String.encode.
-    #
-    # source://json//lib/json/common.rb#670
-    def iconv(to, from, string); end
-
     # :call-seq:
     #   JSON.load(source, proc = nil, options = {}) -> object
     #
     # Returns the Ruby objects created by parsing the given +source+.
     #
+    # BEWARE: This method is meant to serialise data from trusted user input,
+    # like from your own database server or clients under your control, it could
+    # be dangerous to allow untrusted users to pass JSON sources into it.
+    # If you must use it, use JSON.unsafe_load instead to make it clear.
+    #
+    # Since JSON version 2.8.0, `load` emits a deprecation warning when a
+    # non native type is deserialized, without `create_additions` being explicitly
+    # enabled, and in JSON version 3.0, `load` will have `create_additions` disabled
+    # by default.
+    #
     # - Argument +source+ must be, or be convertible to, a \String:
     #   - If +source+ responds to instance method +to_str+,
     #     <tt>source.to_str</tt> becomes the source.
@@ -1160,9 +1270,6 @@ module JSON
     # - Argument +proc+, if given, must be a \Proc that accepts one argument.
     #   It will be called recursively with each result (depth-first order).
     #   See details below.
-    #   BEWARE: This method is meant to serialise data from trusted user input,
-    #   like from your own database server or clients under your control, it could
-    #   be dangerous to allow untrusted users to pass JSON sources into it.
     # - Argument +opts+, if given, contains a \Hash of options for the parsing.
     #   See {Parsing Options}[#module-JSON-label-Parsing+Options].
     #   The default options can be changed via method JSON.load_default_options=.
@@ -1173,17 +1280,17 @@ module JSON
     # <tt>parse(source, opts)</tt>;  see #parse.
     #
     # Source for following examples:
-    #   source = <<-EOT
-    #   {
-    #   "name": "Dave",
-    #     "age" :40,
-    #     "hats": [
-    #       "Cattleman's",
-    #       "Panama",
-    #       "Tophat"
-    #     ]
-    #   }
-    #   EOT
+    #   source = <<~JSON
+    #     {
+    #       "name": "Dave",
+    #       "age" :40,
+    #       "hats": [
+    #         "Cattleman's",
+    #         "Panama",
+    #         "Tophat"
+    #       ]
+    #     }
+    #   JSON
     #
     # Load a \String:
     #   ruby = JSON.load(source)
@@ -1269,25 +1376,9 @@ module JSON
     #      #<Admin:0x00000000064c41f8
     #      @attributes={"type"=>"Admin", "password"=>"0wn3d"}>}
     #
-    # source://json//lib/json/common.rb#549
+    # source://json//lib/json/common.rb#826
     def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
 
-    # Sets or returns default options for the JSON.load method.
-    # Initially:
-    #   opts = JSON.load_default_options
-    #   opts # => {:max_nesting=>false, :allow_nan=>true, :allow_blank=>true, :create_additions=>true}
-    #
-    # source://json//lib/json/common.rb#412
-    def load_default_options; end
-
-    # Sets or returns default options for the JSON.load method.
-    # Initially:
-    #   opts = JSON.load_default_options
-    #   opts # => {:max_nesting=>false, :allow_nan=>true, :allow_blank=>true, :create_additions=>true}
-    #
-    # source://json//lib/json/common.rb#412
-    def load_default_options=(_arg0); end
-
     # :call-seq:
     #   JSON.load_file(path, opts={}) -> object
     #
@@ -1296,7 +1387,7 @@ module JSON
     #
     # See method #parse.
     #
-    # source://json//lib/json/common.rb#257
+    # source://json//lib/json/common.rb#373
     def load_file(filespec, opts = T.unsafe(nil)); end
 
     # :call-seq:
@@ -1307,7 +1398,7 @@ module JSON
     #
     # See method #parse!
     #
-    # source://json//lib/json/common.rb#268
+    # source://json//lib/json/common.rb#384
     def load_file!(filespec, opts = T.unsafe(nil)); end
 
     # :call-seq:
@@ -1338,17 +1429,17 @@ module JSON
     # {Parsing \JSON}[#module-JSON-label-Parsing+JSON].
     #
     # Parses nested JSON objects:
-    #   source = <<-EOT
-    #   {
-    #   "name": "Dave",
-    #     "age" :40,
-    #     "hats": [
-    #       "Cattleman's",
-    #       "Panama",
-    #       "Tophat"
-    #     ]
-    #   }
-    #   EOT
+    #   source = <<~JSON
+    #     {
+    #     "name": "Dave",
+    #       "age" :40,
+    #       "hats": [
+    #         "Cattleman's",
+    #         "Panama",
+    #         "Tophat"
+    #       ]
+    #     }
+    #   JSON
     #   ruby = JSON.parse(source)
     #   ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
     #
@@ -1358,7 +1449,7 @@ module JSON
     #   # Raises JSON::ParserError (783: unexpected token at ''):
     #   JSON.parse('')
     #
-    # source://json//lib/json/common.rb#218
+    # source://json//lib/json/common.rb#336
     def parse(source, opts = T.unsafe(nil)); end
 
     # :call-seq:
@@ -1373,19 +1464,17 @@ module JSON
     #   which disables checking for nesting depth.
     # - Option +allow_nan+, if not provided, defaults to +true+.
     #
-    # source://json//lib/json/common.rb#242
+    # source://json//lib/json/common.rb#358
     def parse!(source, opts = T.unsafe(nil)); end
 
-    # Returns the JSON parser class that is used by JSON. This is either
-    # JSON::Ext::Parser or JSON::Pure::Parser:
-    #   JSON.parser # => JSON::Ext::Parser
+    # Returns the JSON parser class that is used by JSON.
     #
-    # source://json//lib/json/common.rb#38
+    # source://json//lib/json/common.rb#140
     def parser; end
 
     # Set the JSON parser class _parser_ to be used by JSON.
     #
-    # source://json//lib/json/common.rb#41
+    # source://json//lib/json/common.rb#143
     def parser=(parser); end
 
     # :call-seq:
@@ -1418,51 +1507,261 @@ module JSON
     #     }
     #   }
     #
-    # source://json//lib/json/common.rb#382
+    # source://json//lib/json/common.rb#492
     def pretty_generate(obj, opts = T.unsafe(nil)); end
 
-    # :stopdoc:
-    # I want to deprecate these later, so I'll first be silent about them, and later delete them.
-    #
-    # source://json//lib/json/common.rb#382
-    def pretty_unparse(obj, opts = T.unsafe(nil)); end
-
-    # Recursively calls passed _Proc_ if the parsed data structure is an _Array_ or _Hash_
-    #
-    # source://json//lib/json/common.rb#575
-    def recurse_proc(result, &proc); end
+    # source://json//lib/json/common.rb#947
+    def pretty_unparse(*_arg0, **_arg1, &_arg2); end
 
-    # source://json//lib/json/common.rb#549
-    def restore(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
+    # source://json//lib/json/common.rb#957
+    def restore(*_arg0, **_arg1, &_arg2); end
 
-    # Sets or Returns the JSON generator state class that is used by JSON. This is
-    # either JSON::Ext::Generator::State or JSON::Pure::Generator::State:
-    #   JSON.state # => JSON::Ext::Generator::State
+    # Sets or Returns the JSON generator state class that is used by JSON.
     #
-    # source://json//lib/json/common.rb#117
+    # source://json//lib/json/common.rb#184
     def state; end
 
-    # Sets or Returns the JSON generator state class that is used by JSON. This is
-    # either JSON::Ext::Generator::State or JSON::Pure::Generator::State:
-    #   JSON.state # => JSON::Ext::Generator::State
+    # Sets or Returns the JSON generator state class that is used by JSON.
     #
-    # source://json//lib/json/common.rb#117
+    # source://json//lib/json/common.rb#184
     def state=(_arg0); end
 
     # :stopdoc:
-    # I want to deprecate these later, so I'll first be silent about them, and
-    # later delete them.
+    # All these were meant to be deprecated circa 2009, but were just set as undocumented
+    # so usage still exist in the wild.
+    #
+    # source://json//lib/json/common.rb#927
+    def unparse(*_arg0, **_arg1, &_arg2); end
+
+    # :call-seq:
+    #   JSON.unsafe_load(source, proc = nil, options = {}) -> object
+    #
+    # Returns the Ruby objects created by parsing the given +source+.
+    #
+    # BEWARE: This method is meant to serialise data from trusted user input,
+    # like from your own database server or clients under your control, it could
+    # be dangerous to allow untrusted users to pass JSON sources into it.
+    #
+    # - Argument +source+ must be, or be convertible to, a \String:
+    #   - If +source+ responds to instance method +to_str+,
+    #     <tt>source.to_str</tt> becomes the source.
+    #   - If +source+ responds to instance method +to_io+,
+    #     <tt>source.to_io.read</tt> becomes the source.
+    #   - If +source+ responds to instance method +read+,
+    #     <tt>source.read</tt> becomes the source.
+    #   - If both of the following are true, source becomes the \String <tt>'null'</tt>:
+    #     - Option +allow_blank+ specifies a truthy value.
+    #     - The source, as defined above, is +nil+ or the empty \String <tt>''</tt>.
+    #   - Otherwise, +source+ remains the source.
+    # - Argument +proc+, if given, must be a \Proc that accepts one argument.
+    #   It will be called recursively with each result (depth-first order).
+    #   See details below.
+    # - Argument +opts+, if given, contains a \Hash of options for the parsing.
+    #   See {Parsing Options}[#module-JSON-label-Parsing+Options].
+    #   The default options can be changed via method JSON.unsafe_load_default_options=.
+    #
+    # ---
+    #
+    # When no +proc+ is given, modifies +source+ as above and returns the result of
+    # <tt>parse(source, opts)</tt>;  see #parse.
+    #
+    # Source for following examples:
+    #   source = <<~JSON
+    #     {
+    #       "name": "Dave",
+    #       "age" :40,
+    #       "hats": [
+    #         "Cattleman's",
+    #         "Panama",
+    #         "Tophat"
+    #       ]
+    #     }
+    #   JSON
+    #
+    # Load a \String:
+    #   ruby = JSON.unsafe_load(source)
+    #   ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
+    #
+    # Load an \IO object:
+    #   require 'stringio'
+    #   object = JSON.unsafe_load(StringIO.new(source))
+    #   object # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
+    #
+    # Load a \File object:
+    #   path = 't.json'
+    #   File.write(path, source)
+    #   File.open(path) do |file|
+    #     JSON.unsafe_load(file)
+    #   end # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
+    #
+    # ---
+    #
+    # When +proc+ is given:
+    # - Modifies +source+ as above.
+    # - Gets the +result+ from calling <tt>parse(source, opts)</tt>.
+    # - Recursively calls <tt>proc(result)</tt>.
+    # - Returns the final result.
+    #
+    # Example:
+    #   require 'json'
+    #
+    #   # Some classes for the example.
+    #   class Base
+    #     def initialize(attributes)
+    #       @attributes = attributes
+    #     end
+    #   end
+    #   class User    < Base; end
+    #   class Account < Base; end
+    #   class Admin   < Base; end
+    #   # The JSON source.
+    #   json = <<-EOF
+    #   {
+    #     "users": [
+    #         {"type": "User", "username": "jane", "email": "jane@example.com"},
+    #         {"type": "User", "username": "john", "email": "john@example.com"}
+    #     ],
+    #     "accounts": [
+    #         {"account": {"type": "Account", "paid": true, "account_id": "1234"}},
+    #         {"account": {"type": "Account", "paid": false, "account_id": "1235"}}
+    #     ],
+    #     "admins": {"type": "Admin", "password": "0wn3d"}
+    #   }
+    #   EOF
+    #   # Deserializer method.
+    #   def deserialize_obj(obj, safe_types = %w(User Account Admin))
+    #     type = obj.is_a?(Hash) && obj["type"]
+    #     safe_types.include?(type) ? Object.const_get(type).new(obj) : obj
+    #   end
+    #   # Call to JSON.unsafe_load
+    #   ruby = JSON.unsafe_load(json, proc {|obj|
+    #     case obj
+    #     when Hash
+    #       obj.each {|k, v| obj[k] = deserialize_obj v }
+    #     when Array
+    #       obj.map! {|v| deserialize_obj v }
+    #     end
+    #   })
+    #   pp ruby
+    # Output:
+    #   {"users"=>
+    #      [#<User:0x00000000064c4c98
+    #        @attributes=
+    #          {"type"=>"User", "username"=>"jane", "email"=>"jane@example.com"}>,
+    #        #<User:0x00000000064c4bd0
+    #        @attributes=
+    #          {"type"=>"User", "username"=>"john", "email"=>"john@example.com"}>],
+    #    "accounts"=>
+    #      [{"account"=>
+    #          #<Account:0x00000000064c4928
+    #          @attributes={"type"=>"Account", "paid"=>true, "account_id"=>"1234"}>},
+    #       {"account"=>
+    #          #<Account:0x00000000064c4680
+    #          @attributes={"type"=>"Account", "paid"=>false, "account_id"=>"1235"}>}],
+    #    "admins"=>
+    #      #<Admin:0x00000000064c41f8
+    #      @attributes={"type"=>"Admin", "password"=>"0wn3d"}>}
     #
-    # source://json//lib/json/common.rb#308
-    def unparse(obj, opts = T.unsafe(nil)); end
+    # source://json//lib/json/common.rb#666
+    def unsafe_load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
 
     private
 
-    # source://json//lib/json/common.rb#674
-    def merge_dump_options(opts, strict: T.unsafe(nil)); end
+    # source://json//lib/json/common.rb#970
+    def const_missing(const_name); end
+
+    # source://json//lib/json/common.rb#188
+    def deprecated_singleton_attr_accessor(*attrs); end
   end
 end
 
+# JSON::Coder holds a parser and generator configuration.
+#
+#   module MyApp
+#     JSONC_CODER = JSON::Coder.new(
+#       allow_trailing_comma: true
+#     )
+#   end
+#
+#   MyApp::JSONC_CODER.load(document)
+#
+# source://json//lib/json/common.rb#996
+class JSON::Coder
+  # :call-seq:
+  #   JSON.new(options = nil, &block)
+  #
+  # Argument +options+, if given, contains a \Hash of options for both parsing and generating.
+  # See {Parsing Options}[#module-JSON-label-Parsing+Options], and {Generating Options}[#module-JSON-label-Generating+Options].
+  #
+  # For generation, the <tt>strict: true</tt> option is always set. When a Ruby object with no native \JSON counterpart is
+  # encoutered, the block provided to the initialize method is invoked, and must return a Ruby object that has a native
+  # \JSON counterpart:
+  #
+  #  module MyApp
+  #    API_JSON_CODER = JSON::Coder.new do |object|
+  #      case object
+  #      when Time
+  #        object.iso8601(3)
+  #      else
+  #        object # Unknown type, will raise
+  #      end
+  #    end
+  #  end
+  #
+  #  puts MyApp::API_JSON_CODER.dump(Time.now.utc) # => "2025-01-21T08:41:44.286Z"
+  #
+  # @return [Coder] a new instance of Coder
+  #
+  # source://json//lib/json/common.rb#1020
+  def initialize(options = T.unsafe(nil), &as_json); end
+
+  # call-seq:
+  #   dump(object) -> String
+  #   dump(object, io) -> io
+  #
+  # Serialize the given object into a \JSON document.
+  #
+  # source://json//lib/json/common.rb#1038
+  def dump(object, io = T.unsafe(nil)); end
+
+  # call-seq:
+  #   dump(object) -> String
+  #   dump(object, io) -> io
+  #
+  # Serialize the given object into a \JSON document.
+  #
+  # source://json//lib/json/common.rb#1038
+  def generate(object, io = T.unsafe(nil)); end
+
+  # call-seq:
+  #   load(string) -> Object
+  #
+  # Parse the given \JSON document and return an equivalent Ruby object.
+  #
+  # source://json//lib/json/common.rb#1047
+  def load(source); end
+
+  # call-seq:
+  #   load(path) -> Object
+  #
+  # Parse the given \JSON document and return an equivalent Ruby object.
+  #
+  # source://json//lib/json/common.rb#1056
+  def load_file(path); end
+
+  # call-seq:
+  #   load(string) -> Object
+  #
+  # Parse the given \JSON document and return an equivalent Ruby object.
+  #
+  # source://json//lib/json/common.rb#1047
+  def parse(source); end
+end
+
+module JSON::Ext::Generator::GeneratorMethods::String
+  mixes_in_class_methods ::JSON::Ext::Generator::GeneratorMethods::String::Extend
+end
+
 # source://json//lib/json/ext/generator/state.rb#6
 class JSON::Ext::Generator::State
   # call-seq: new(opts = {})
@@ -1493,14 +1792,14 @@ class JSON::Ext::Generator::State
   #
   # Returns the value returned by method +name+.
   #
-  # source://json//lib/json/ext/generator/state.rb#113
+  # source://json//lib/json/ext/generator/state.rb#84
   def [](name); end
 
   # call-seq: []=(name, value)
   #
   # Sets the attribute name to value.
   #
-  # source://json//lib/json/ext/generator/state.rb#125
+  # source://json//lib/json/ext/generator/state.rb#96
   def []=(name, value); end
 
   # call-seq: configure(opts)
@@ -1524,7 +1823,7 @@ class JSON::Ext::Generator::State
   # Returns the configuration instance variables as a hash, that can be
   # passed to the configure method.
   #
-  # source://json//lib/json/ext/generator/state.rb#84
+  # source://json//lib/json/ext/generator/state.rb#54
   def to_h; end
 
   # call-seq: to_h
@@ -1532,10 +1831,86 @@ class JSON::Ext::Generator::State
   # Returns the configuration instance variables as a hash, that can be
   # passed to the configure method.
   #
-  # source://json//lib/json/ext/generator/state.rb#84
+  # source://json//lib/json/ext/generator/state.rb#54
   def to_hash; end
 end
 
+# source://json//lib/json/ext.rb#9
+class JSON::Ext::Parser
+  # @return [Parser] a new instance of Parser
+  #
+  # source://json//lib/json/ext.rb#17
+  def initialize(source, opts = T.unsafe(nil)); end
+
+  # source://json//lib/json/ext.rb#26
+  def parse; end
+
+  # source://json//lib/json/ext.rb#22
+  def source; end
+end
+
+# source://json//lib/json/ext.rb#32
+JSON::Ext::Parser::Config = JSON::Ext::ParserConfig
+
+# Fragment of JSON document that is to be included as is:
+#   fragment = JSON::Fragment.new("[1, 2, 3]")
+#   JSON.generate({ count: 3, items: fragments })
+#
+# This allows to easily assemble multiple JSON fragments that have
+# been persisted somewhere without having to parse them nor resorting
+# to string interpolation.
+#
+# Note: no validation is performed on the provided string. It is the
+# responsability of the caller to ensure the string contains valid JSON.
+#
+# source://json//lib/json/common.rb#272
+class JSON::Fragment < ::Struct
+  # @return [Fragment] a new instance of Fragment
+  #
+  # source://json//lib/json/common.rb#273
+  def initialize(json); end
+
+  # Returns the value of attribute json
+  #
+  # @return [Object] the current value of json
+  def json; end
+
+  # Sets the attribute json
+  #
+  # @param value [Object] the value to set the attribute json to.
+  # @return [Object] the newly set value
+  def json=(_); end
+
+  # source://json//lib/json/common.rb#281
+  def to_json(state = T.unsafe(nil), *_arg1); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# This exception is raised if a generator or unparser error occurs.
+#
+# source://json//lib/json/common.rb#242
+class JSON::GeneratorError < ::JSON::JSONError
+  # @return [GeneratorError] a new instance of GeneratorError
+  #
+  # source://json//lib/json/common.rb#245
+  def initialize(message, invalid_object = T.unsafe(nil)); end
+
+  # source://json//lib/json/common.rb#250
+  def detailed_message(*_arg0, **_arg1, &_arg2); end
+
+  # Returns the value of attribute invalid_object.
+  #
+  # source://json//lib/json/common.rb#243
+  def invalid_object; end
+end
+
 # source://json//lib/json/generic_object.rb#9
 class JSON::GenericObject < ::OpenStruct
   # source://json//lib/json/generic_object.rb#67
@@ -1577,31 +1952,58 @@ class JSON::GenericObject < ::OpenStruct
   end
 end
 
-# The base exception for JSON errors.
+# source://json//lib/json/common.rb#341
+JSON::PARSE_L_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+# source://json//lib/json/common.rb#454
+JSON::PRETTY_GENERATE_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+# source://json//lib/json/common.rb#146
+JSON::Parser = JSON::Ext::Parser
+
+# This exception is raised if a parser error occurs.
 #
-# source://json//lib/json/common.rb#140
-class JSON::JSONError < ::StandardError
-  class << self
-    # source://json//lib/json/common.rb#141
-    def wrap(exception); end
-  end
+# source://json//lib/json/common.rb#233
+class JSON::ParserError < ::JSON::JSONError
+  # Returns the value of attribute column.
+  #
+  # source://json//lib/json/common.rb#234
+  def column; end
+
+  # Returns the value of attribute line.
+  #
+  # source://json//lib/json/common.rb#234
+  def line; end
 end
 
-# source://json//lib/json/common.rb#7
-JSON::NOT_SET = T.let(T.unsafe(nil), Object)
+# source://json//lib/json/common.rb#8
+module JSON::ParserOptions
+  class << self
+    # source://json//lib/json/common.rb#10
+    def prepare(opts); end
 
-# source://json//lib/json/common.rb#44
-JSON::Parser = JSON::Ext::Parser
+    private
 
-# source://json//lib/json/common.rb#82
-JSON::State = JSON::Ext::Generator::State
+    # source://json//lib/json/common.rb#40
+    def array_class_proc(array_class, on_load); end
 
-# For backwards compatibility
-#
-# source://json//lib/json/common.rb#162
-JSON::UnparserError = JSON::GeneratorError
+    # TODO: exctract :create_additions support to another gem for version 3.0
+    #
+    # source://json//lib/json/common.rb#52
+    def create_additions_proc(opts); end
+
+    # source://json//lib/json/common.rb#91
+    def create_additions_warning; end
+
+    # source://json//lib/json/common.rb#29
+    def object_class_proc(object_class, on_load); end
+  end
+end
+
+# source://json//lib/json/common.rb#175
+JSON::State = JSON::Ext::Generator::State
 
-# source://json//lib/json/common.rb#684
+# source://json//lib/json/common.rb#1062
 module Kernel
   private
 
@@ -1612,18 +2014,38 @@ module Kernel
   # The _opts_ argument is passed through to generate/parse respectively. See
   # generate and parse for their documentation.
   #
-  # source://json//lib/json/common.rb#711
-  def JSON(object, *args); end
+  # source://json//lib/json/common.rb#1101
+  def JSON(object, opts = T.unsafe(nil)); end
 
   # Outputs _objs_ to STDOUT as JSON strings in the shortest form, that is in
   # one line.
   #
-  # source://json//lib/json/common.rb#689
+  # source://json//lib/json/common.rb#1067
   def j(*objs); end
 
   # Outputs _objs_ to STDOUT as JSON strings in a pretty format, with
   # indentation and over many lines.
   #
-  # source://json//lib/json/common.rb#698
+  # source://json//lib/json/common.rb#1082
   def jj(*objs); end
 end
+
+class NilClass
+  include ::JSON::Ext::Generator::GeneratorMethods::NilClass
+end
+
+class Object < ::BasicObject
+  include ::Kernel
+  include ::PP::ObjectMixin
+  include ::JSON::Ext::Generator::GeneratorMethods::Object
+end
+
+class String
+  include ::Comparable
+  include ::JSON::Ext::Generator::GeneratorMethods::String
+  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
+end
+
+class TrueClass
+  include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
+end