rbs 2.0.0 → 2.1.0

data/stdlib/json/0/json.rbs

@@ -20,15 +20,44 @@ end
 
 type json_options = Hash[Symbol, untyped]
 
+# <!-- rdoc-file=ext/json/lib/json/common.rb -->
+# The base exception for JSON errors.
+#
+class JSON::JSONError < StandardError
+end
+
+# <!-- rdoc-file=ext/json/lib/json/common.rb -->
+# This exception is raised if a generator or unparser error occurs.
+#
+class JSON::GeneratorError < JSON::JSONError
+end
+
+class JSON::UnparserError < JSON::GeneratorError
+end
+
+# <!-- rdoc-file=ext/json/lib/json/common.rb -->
+# This exception is raised if a parser error occurs.
+#
+class JSON::ParserError < JSON::JSONError
+end
+
+# <!-- rdoc-file=ext/json/lib/json/common.rb -->
+# This exception is raised if the nesting of parsed data structures is too deep.
+#
+class JSON::NestingError < JSON::ParserError
+end
+
 class JSON::State
 end
 
+# <!-- rdoc-file=ext/json/lib/json/ext.rb -->
 # This module holds all the modules/classes that implement JSON's functionality
 # as C extensions.
 #
 module JSON::Ext
 end
 
+# <!-- rdoc-file=ext/json/generator/generator.c -->
 # This is the JSON generator implemented as a C extension. It can be configured
 # to be used by setting
 #
@@ -42,6 +71,14 @@ end
 class JSON::Ext::Generator::State
 end
 
+# <!-- rdoc-file=ext/json/parser/parser.c -->
+# This is the JSON parser implemented as a C extension. It can be configured to
+# be used by setting
+#
+#     JSON.parser = JSON::Ext::Parser
+#
+# with the method parser= in JSON.
+#
 class JSON::Ext::Parser
 end
 
@@ -61,238 +98,1005 @@ type json_generator = singleton(::JSON::Ext::Generator) | singleton(::JSON::Pure
 type json_parser = singleton(::JSON::Ext::Parser) | singleton(::JSON::Pure::Parser)
 type json_state = singleton(JSON::Ext::Generator::State) | singleton(JSON::Pure::Generator::State)
 
+# <!-- rdoc-file=ext/json/lib/json.rb -->
 # # JavaScript Object Notation (JSON)
 #
-# JSON is a lightweight data-interchange format. It is easy for us humans to
-# read and write. Plus, equally simple for machines to generate or parse. JSON
-# is completely language agnostic, making it the ideal interchange format.
+# JSON is a lightweight data-interchange format.
 #
-# Built on two universally available structures:
-#     1. A collection of name/value pairs. Often referred to as an _object_, hash table, record, struct, keyed list, or associative array.
-#     2. An ordered list of values. More commonly called an _array_, vector, sequence or list.
+# A JSON value is one of the following:
+# *   Double-quoted text:  `"foo"`.
+# *   Number:  `1`, `1.0`, `2.0e2`.
+# *   Boolean:  `true`, `false`.
+# *   Null: `null`.
+# *   Array: an ordered list of values, enclosed by square brackets:
+#         ["foo", 1, 1.0, 2.0e2, true, false, null]
 #
-# To read more about JSON visit: http://json.org
+# *   Object: a collection of name/value pairs, enclosed by curly braces; each
+#     name is double-quoted text; the values may be any JSON values:
+#         {"a": "foo", "b": 1, "c": 1.0, "d": 2.0e2, "e": true, "f": false, "g": null}
 #
-# ## Parsing JSON
 #
-# To parse a JSON string received by another application or generated within
-# your existing application:
+# A JSON array or object may contain nested arrays, objects, and scalars to any
+# depth:
+#     {"foo": {"bar": 1, "baz": 2}, "bat": [0, 1, 2]}
+#     [{"foo": 0, "bar": 1}, ["baz", 2]]
 #
+# ## Using Module JSON
+#
+# To make module JSON available in your code, begin with:
 #     require 'json'
 #
-#     my_hash = JSON.parse('{"hello": "goodbye"}')
-#     puts my_hash["hello"] => "goodbye"
+# All examples here assume that this has been done.
 #
-# Notice the extra quotes `''` around the hash notation. Ruby expects the
-# argument to be a string and can't convert objects like a hash or array.
+# ### Parsing JSON
 #
-# Ruby converts your string into a hash
+# You can parse a String containing JSON data using either of two methods:
+# *   `JSON.parse(source, opts)`
+# *   `JSON.parse!(source, opts)`
 #
-# ## Generating JSON
 #
-# Creating a JSON string for communication or serialization is just as simple.
+# where
+# *   `source` is a Ruby object.
+# *   `opts` is a Hash object containing options that control both input allowed
+#     and output formatting.
 #
-#     require 'json'
 #
-#     my_hash = {:hello => "goodbye"}
-#     puts JSON.generate(my_hash) => "{\"hello\":\"goodbye\"}"
+# The difference between the two methods is that JSON.parse! omits some checks
+# and may not be safe for some `source` data; use it only for data from trusted
+# sources. Use the safer method JSON.parse for less trusted sources.
 #
-# Or an alternative way:
+# #### Parsing JSON Arrays
 #
-#     require 'json'
-#     puts {:hello => "goodbye"}.to_json => "{\"hello\":\"goodbye\"}"
+# When `source` is a JSON array, JSON.parse by default returns a Ruby Array:
+#     json = '["foo", 1, 1.0, 2.0e2, true, false, null]'
+#     ruby = JSON.parse(json)
+#     ruby # => ["foo", 1, 1.0, 200.0, true, false, nil]
+#     ruby.class # => Array
+#
+# The JSON array may contain nested arrays, objects, and scalars to any depth:
+#     json = '[{"foo": 0, "bar": 1}, ["baz", 2]]'
+#     JSON.parse(json) # => [{"foo"=>0, "bar"=>1}, ["baz", 2]]
+#
+# #### Parsing JSON Objects
+#
+# When the source is a JSON object, JSON.parse by default returns a Ruby Hash:
+#     json = '{"a": "foo", "b": 1, "c": 1.0, "d": 2.0e2, "e": true, "f": false, "g": null}'
+#     ruby = JSON.parse(json)
+#     ruby # => {"a"=>"foo", "b"=>1, "c"=>1.0, "d"=>200.0, "e"=>true, "f"=>false, "g"=>nil}
+#     ruby.class # => Hash
+#
+# The JSON object may contain nested arrays, objects, and scalars to any depth:
+#     json = '{"foo": {"bar": 1, "baz": 2}, "bat": [0, 1, 2]}'
+#     JSON.parse(json) # => {"foo"=>{"bar"=>1, "baz"=>2}, "bat"=>[0, 1, 2]}
+#
+# #### Parsing JSON Scalars
+#
+# When the source is a JSON scalar (not an array or object), JSON.parse returns
+# a Ruby scalar.
+#
+# String:
+#     ruby = JSON.parse('"foo"')
+#     ruby # => 'foo'
+#     ruby.class # => String
+#
+# Integer:
+#     ruby = JSON.parse('1')
+#     ruby # => 1
+#     ruby.class # => Integer
+#
+# Float:
+#     ruby = JSON.parse('1.0')
+#     ruby # => 1.0
+#     ruby.class # => Float
+#     ruby = JSON.parse('2.0e2')
+#     ruby # => 200
+#     ruby.class # => Float
+#
+# Boolean:
+#     ruby = JSON.parse('true')
+#     ruby # => true
+#     ruby.class # => TrueClass
+#     ruby = JSON.parse('false')
+#     ruby # => false
+#     ruby.class # => FalseClass
+#
+# Null:
+#     ruby = JSON.parse('null')
+#     ruby # => nil
+#     ruby.class # => NilClass
+#
+# #### Parsing Options
+#
+# ###### Input Options
+#
+# Option `max_nesting` (Integer) specifies the maximum nesting depth allowed;
+# defaults to `100`; specify `false` to disable depth checking.
+#
+# With the default, `false`:
+#     source = '[0, [1, [2, [3]]]]'
+#     ruby = JSON.parse(source)
+#     ruby # => [0, [1, [2, [3]]]]
+#
+# Too deep:
+#     # Raises JSON::NestingError (nesting of 2 is too deep):
+#     JSON.parse(source, {max_nesting: 1})
+#
+# Bad value:
+#     # Raises TypeError (wrong argument type Symbol (expected Fixnum)):
+#     JSON.parse(source, {max_nesting: :foo})
+#
+# ---
+#
+# Option `allow_nan` (boolean) specifies whether to allow NaN, Infinity, and
+# MinusInfinity in `source`; defaults to `false`.
+#
+# With the default, `false`:
+#     # Raises JSON::ParserError (225: unexpected token at '[NaN]'):
+#     JSON.parse('[NaN]')
+#     # Raises JSON::ParserError (232: unexpected token at '[Infinity]'):
+#     JSON.parse('[Infinity]')
+#     # Raises JSON::ParserError (248: unexpected token at '[-Infinity]'):
+#     JSON.parse('[-Infinity]')
+#
+# Allow:
+#     source = '[NaN, Infinity, -Infinity]'
+#     ruby = JSON.parse(source, {allow_nan: true})
+#     ruby # => [NaN, Infinity, -Infinity]
+#
+# ###### Output Options
+#
+# Option `symbolize_names` (boolean) specifies whether returned Hash keys should
+# be Symbols; defaults to `false` (use Strings).
+#
+# With the default, `false`:
+#     source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}'
+#     ruby = JSON.parse(source)
+#     ruby # => {"a"=>"foo", "b"=>1.0, "c"=>true, "d"=>false, "e"=>nil}
+#
+# Use Symbols:
+#     ruby = JSON.parse(source, {symbolize_names: true})
+#     ruby # => {:a=>"foo", :b=>1.0, :c=>true, :d=>false, :e=>nil}
+#
+# ---
+#
+# Option `object_class` (Class) specifies the Ruby class to be used for each
+# JSON object; defaults to Hash.
+#
+# With the default, Hash:
+#     source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}'
+#     ruby = JSON.parse(source)
+#     ruby.class # => Hash
+#
+# Use class OpenStruct:
+#     ruby = JSON.parse(source, {object_class: OpenStruct})
+#     ruby # => #<OpenStruct a="foo", b=1.0, c=true, d=false, e=nil>
+#
+# ---
+#
+# Option `array_class` (Class) specifies the Ruby class to be used for each JSON
+# array; defaults to Array.
+#
+# With the default, Array:
+#     source = '["foo", 1.0, true, false, null]'
+#     ruby = JSON.parse(source)
+#     ruby.class # => Array
+#
+# Use class Set:
+#     ruby = JSON.parse(source, {array_class: Set})
+#     ruby # => #<Set: {"foo", 1.0, true, false, nil}>
+#
+# ---
+#
+# Option `create_additions` (boolean) specifies whether to use JSON additions in
+# parsing. See [\JSON Additions](#module-JSON-label-JSON+Additions).
+#
+# ### Generating JSON
+#
+# To generate a Ruby String containing JSON data, use method
+# `JSON.generate(source, opts)`, where
+# *   `source` is a Ruby object.
+# *   `opts` is a Hash object containing options that control both input allowed
+#     and output formatting.
+#
+#
+# #### Generating JSON from Arrays
+#
+# When the source is a Ruby Array, JSON.generate returns a String containing a
+# JSON array:
+#     ruby = [0, 's', :foo]
+#     json = JSON.generate(ruby)
+#     json # => '[0,"s","foo"]'
+#
+# The Ruby Array array may contain nested arrays, hashes, and scalars to any
+# depth:
+#     ruby = [0, [1, 2], {foo: 3, bar: 4}]
+#     json = JSON.generate(ruby)
+#     json # => '[0,[1,2],{"foo":3,"bar":4}]'
+#
+# #### Generating JSON from Hashes
+#
+# When the source is a Ruby Hash, JSON.generate returns a String containing a
+# JSON object:
+#     ruby = {foo: 0, bar: 's', baz: :bat}
+#     json = JSON.generate(ruby)
+#     json # => '{"foo":0,"bar":"s","baz":"bat"}'
+#
+# The Ruby Hash array may contain nested arrays, hashes, and scalars to any
+# depth:
+#     ruby = {foo: [0, 1], bar: {baz: 2, bat: 3}, bam: :bad}
+#     json = JSON.generate(ruby)
+#     json # => '{"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"}'
+#
+# #### Generating JSON from Other Objects
+#
+# When the source is neither an Array nor a Hash, the generated JSON data
+# depends on the class of the source.
+#
+# When the source is a Ruby Integer or Float, JSON.generate returns a String
+# containing a JSON number:
+#     JSON.generate(42) # => '42'
+#     JSON.generate(0.42) # => '0.42'
+#
+# When the source is a Ruby String, JSON.generate returns a String containing a
+# JSON string (with double-quotes):
+#     JSON.generate('A string') # => '"A string"'
+#
+# When the source is `true`, `false` or `nil`, JSON.generate returns a String
+# containing the corresponding JSON token:
+#     JSON.generate(true) # => 'true'
+#     JSON.generate(false) # => 'false'
+#     JSON.generate(nil) # => 'null'
+#
+# When the source is none of the above, JSON.generate returns a String
+# containing a JSON string representation of the source:
+#     JSON.generate(:foo) # => '"foo"'
+#     JSON.generate(Complex(0, 0)) # => '"0+0i"'
+#     JSON.generate(Dir.new('.')) # => '"#<Dir>"'
+#
+# #### Generating Options
+#
+# ###### Input Options
+#
+# Option `allow_nan` (boolean) specifies whether `NaN`, `Infinity`, and
+# `-Infinity` may be generated; defaults to `false`.
 #
-# `JSON.generate` only allows objects or arrays to be converted to JSON syntax.
-# `to_json`, however, accepts many Ruby classes even though it acts only as a
-# method for serialization:
+# With the default, `false`:
+#     # Raises JSON::GeneratorError (920: NaN not allowed in JSON):
+#     JSON.generate(JSON::NaN)
+#     # Raises JSON::GeneratorError (917: Infinity not allowed in JSON):
+#     JSON.generate(JSON::Infinity)
+#     # Raises JSON::GeneratorError (917: -Infinity not allowed in JSON):
+#     JSON.generate(JSON::MinusInfinity)
 #
+# Allow:
+#     ruby = [Float::NaN, Float::Infinity, Float::MinusInfinity]
+#     JSON.generate(ruby, allow_nan: true) # => '[NaN,Infinity,-Infinity]'
+#
+# ---
+#
+# Option `max_nesting` (Integer) specifies the maximum nesting depth in `obj`;
+# defaults to `100`.
+#
+# With the default, `100`:
+#     obj = [[[[[[0]]]]]]
+#     JSON.generate(obj) # => '[[[[[[0]]]]]]'
+#
+# Too deep:
+#     # Raises JSON::NestingError (nesting of 2 is too deep):
+#     JSON.generate(obj, max_nesting: 2)
+#
+# ###### Output Options
+#
+# The default formatting options generate the most compact JSON data, all on one
+# line and with no whitespace.
+#
+# You can use these formatting options to generate JSON data in a more open
+# format, using whitespace. See also JSON.pretty_generate.
+#
+# *   Option `array_nl` (String) specifies a string (usually a newline) to be
+#     inserted after each JSON array; defaults to the empty String, `''`.
+# *   Option `object_nl` (String) specifies a string (usually a newline) to be
+#     inserted after each JSON object; defaults to the empty String, `''`.
+# *   Option `indent` (String) specifies the string (usually spaces) to be used
+#     for indentation; defaults to the empty String, `''`; defaults to the empty
+#     String, `''`; has no effect unless options `array_nl` or `object_nl`
+#     specify newlines.
+# *   Option `space` (String) specifies a string (usually a space) to be
+#     inserted after the colon in each JSON object's pair; defaults to the empty
+#     String, `''`.
+# *   Option `space_before` (String) specifies a string (usually a space) to be
+#     inserted before the colon in each JSON object's pair; defaults to the
+#     empty String, `''`.
+#
+#
+# In this example, `obj` is used first to generate the shortest JSON data (no
+# whitespace), then again with all formatting options specified:
+#
+#     obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}}
+#     json = JSON.generate(obj)
+#     puts 'Compact:', json
+#     opts = {
+#       array_nl: "\n",
+#       object_nl: "\n",
+#       indent: '  ',
+#       space_before: ' ',
+#       space: ' '
+#     }
+#     puts 'Open:', JSON.generate(obj, opts)
+#
+# Output:
+#     Compact:
+#     {"foo":["bar","baz"],"bat":{"bam":0,"bad":1}}
+#     Open:
+#     {
+#       "foo" : [
+#         "bar",
+#         "baz"
+#     ],
+#       "bat" : {
+#         "bam" : 0,
+#         "bad" : 1
+#       }
+#     }
+#
+# ## JSON Additions
+#
+# When you "round trip" a non-String object from Ruby to JSON and back, you have
+# a new String, instead of the object you began with:
+#     ruby0 = Range.new(0, 2)
+#     json = JSON.generate(ruby0)
+#     json # => '0..2"'
+#     ruby1 = JSON.parse(json)
+#     ruby1 # => '0..2'
+#     ruby1.class # => String
+#
+# You can use JSON *additions* to preserve the original object. The addition is
+# an extension of a ruby class, so that:
+# *   JSON.generate stores more information in the JSON string.
+# *   JSON.parse, called with option `create_additions`, uses that information
+#     to create a proper Ruby object.
+#
+#
+# This example shows a Range being generated into JSON and parsed back into
+# Ruby, both without and with the addition for Range:
+#     ruby = Range.new(0, 2)
+#     # This passage does not use the addition for Range.
+#     json0 = JSON.generate(ruby)
+#     ruby0 = JSON.parse(json0)
+#     # This passage uses the addition for Range.
+#     require 'json/add/range'
+#     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})
+#     EOT
+#     puts display
+#
+# This output shows the different results:
+#     Generated JSON:
+#       Without addition:  "0..2" (String)
+#       With addition:     {"json_class":"Range","a":[0,2,false]} (String)
+#     Parsed JSON:
+#       Without addition:  "0..2" (String)
+#       With addition:     0..2 (Range)
+#
+# The JSON module includes additions for certain classes. You can also craft
+# custom additions. See [Custom \JSON
+# Additions](#module-JSON-label-Custom+JSON+Additions).
+#
+# ### Built-in Additions
+#
+# The JSON module includes additions for certain classes. To use an addition,
+# `require` its source:
+# *   BigDecimal: `require 'json/add/bigdecimal'`
+# *   Complex: `require 'json/add/complex'`
+# *   Date: `require 'json/add/date'`
+# *   DateTime: `require 'json/add/date_time'`
+# *   Exception: `require 'json/add/exception'`
+# *   OpenStruct: `require 'json/add/ostruct'`
+# *   Range: `require 'json/add/range'`
+# *   Rational: `require 'json/add/rational'`
+# *   Regexp: `require 'json/add/regexp'`
+# *   Set: `require 'json/add/set'`
+# *   Struct: `require 'json/add/struct'`
+# *   Symbol: `require 'json/add/symbol'`
+# *   Time: `require 'json/add/time'`
+#
+#
+# To reduce punctuation clutter, the examples below show the generated JSON via
+# `puts`, rather than the usual `inspect`,
+#
+# BigDecimal:
+#     require 'json/add/bigdecimal'
+#     ruby0 = BigDecimal(0) # 0.0
+#     json = JSON.generate(ruby0) # {"json_class":"BigDecimal","b":"27:0.0"}
+#     ruby1 = JSON.parse(json, create_additions: true) # 0.0
+#     ruby1.class # => BigDecimal
+#
+# Complex:
+#     require 'json/add/complex'
+#     ruby0 = Complex(1+0i) # 1+0i
+#     json = JSON.generate(ruby0) # {"json_class":"Complex","r":1,"i":0}
+#     ruby1 = JSON.parse(json, create_additions: true) # 1+0i
+#     ruby1.class # Complex
+#
+# Date:
+#     require 'json/add/date'
+#     ruby0 = Date.today # 2020-05-02
+#     json = JSON.generate(ruby0) # {"json_class":"Date","y":2020,"m":5,"d":2,"sg":2299161.0}
+#     ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02
+#     ruby1.class # Date
+#
+# DateTime:
+#     require 'json/add/date_time'
+#     ruby0 = DateTime.now # 2020-05-02T10:38:13-05:00
+#     json = JSON.generate(ruby0) # {"json_class":"DateTime","y":2020,"m":5,"d":2,"H":10,"M":38,"S":13,"of":"-5/24","sg":2299161.0}
+#     ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02T10:38:13-05:00
+#     ruby1.class # DateTime
+#
+# Exception (and its subclasses including RuntimeError):
+#     require 'json/add/exception'
+#     ruby0 = Exception.new('A message') # A message
+#     json = JSON.generate(ruby0) # {"json_class":"Exception","m":"A message","b":null}
+#     ruby1 = JSON.parse(json, create_additions: true) # A message
+#     ruby1.class # Exception
+#     ruby0 = RuntimeError.new('Another message') # Another message
+#     json = JSON.generate(ruby0) # {"json_class":"RuntimeError","m":"Another message","b":null}
+#     ruby1 = JSON.parse(json, create_additions: true) # Another message
+#     ruby1.class # RuntimeError
+#
+# OpenStruct:
+#     require 'json/add/ostruct'
+#     ruby0 = OpenStruct.new(name: 'Matz', language: 'Ruby') # #<OpenStruct name="Matz", language="Ruby">
+#     json = JSON.generate(ruby0) # {"json_class":"OpenStruct","t":{"name":"Matz","language":"Ruby"}}
+#     ruby1 = JSON.parse(json, create_additions: true) # #<OpenStruct name="Matz", language="Ruby">
+#     ruby1.class # OpenStruct
+#
+# Range:
+#     require 'json/add/range'
+#     ruby0 = Range.new(0, 2) # 0..2
+#     json = JSON.generate(ruby0) # {"json_class":"Range","a":[0,2,false]}
+#     ruby1 = JSON.parse(json, create_additions: true) # 0..2
+#     ruby1.class # Range
+#
+# Rational:
+#     require 'json/add/rational'
+#     ruby0 = Rational(1, 3) # 1/3
+#     json = JSON.generate(ruby0) # {"json_class":"Rational","n":1,"d":3}
+#     ruby1 = JSON.parse(json, create_additions: true) # 1/3
+#     ruby1.class # Rational
+#
+# Regexp:
+#     require 'json/add/regexp'
+#     ruby0 = Regexp.new('foo') # (?-mix:foo)
+#     json = JSON.generate(ruby0) # {"json_class":"Regexp","o":0,"s":"foo"}
+#     ruby1 = JSON.parse(json, create_additions: true) # (?-mix:foo)
+#     ruby1.class # Regexp
+#
+# Set:
+#     require 'json/add/set'
+#     ruby0 = Set.new([0, 1, 2]) # #<Set: {0, 1, 2}>
+#     json = JSON.generate(ruby0) # {"json_class":"Set","a":[0,1,2]}
+#     ruby1 = JSON.parse(json, create_additions: true) # #<Set: {0, 1, 2}>
+#     ruby1.class # Set
+#
+# Struct:
+#     require 'json/add/struct'
+#     Customer = Struct.new(:name, :address) # Customer
+#     ruby0 = Customer.new("Dave", "123 Main") # #<struct Customer name="Dave", address="123 Main">
+#     json = JSON.generate(ruby0) # {"json_class":"Customer","v":["Dave","123 Main"]}
+#     ruby1 = JSON.parse(json, create_additions: true) # #<struct Customer name="Dave", address="123 Main">
+#     ruby1.class # Customer
+#
+# Symbol:
+#     require 'json/add/symbol'
+#     ruby0 = :foo # foo
+#     json = JSON.generate(ruby0) # {"json_class":"Symbol","s":"foo"}
+#     ruby1 = JSON.parse(json, create_additions: true) # foo
+#     ruby1.class # Symbol
+#
+# Time:
+#     require 'json/add/time'
+#     ruby0 = Time.now # 2020-05-02 11:28:26 -0500
+#     json = JSON.generate(ruby0) # {"json_class":"Time","s":1588436906,"n":840560000}
+#     ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02 11:28:26 -0500
+#     ruby1.class # Time
+#
+# ### Custom JSON Additions
+#
+# In addition to the JSON additions provided, you can craft JSON additions of
+# your own, either for Ruby built-in classes or for user-defined classes.
+#
+# Here's a user-defined class `Foo`:
+#     class Foo
+#       attr_accessor :bar, :baz
+#       def initialize(bar, baz)
+#         self.bar = bar
+#         self.baz = baz
+#       end
+#     end
+#
+# Here's the JSON addition for it:
+#     # Extend class Foo with JSON addition.
+#     class Foo
+#       # Serialize Foo object with its class name and arguments
+#       def to_json(*args)
+#         {
+#           JSON.create_id  => self.class.name,
+#           'a'             => [ bar, baz ]
+#         }.to_json(*args)
+#       end
+#       # Deserialize JSON string by constructing new Foo object with arguments.
+#       def self.json_create(object)
+#         new(*object['a'])
+#       end
+#     end
+#
+# Demonstration:
 #     require 'json'
+#     # This Foo object has no custom addition.
+#     foo0 = Foo.new(0, 1)
+#     json0 = JSON.generate(foo0)
+#     obj0 = JSON.parse(json0)
+#     # Lood the custom addition.
+#     require_relative 'foo_addition'
+#     # This foo has the custom addition.
+#     foo1 = Foo.new(0, 1)
+#     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})
+#     EOT
+#     puts display
+#
+# Output:
 #
-#     1.to_json => "1"
+#     Generated JSON:
+#       Without custom addition:  "#<Foo:0x0000000006534e80>" (String)
+#       With custom addition:     {"json_class":"Foo","a":[0,1]} (String)
+#     Parsed JSON:
+#       Without custom addition:  "#<Foo:0x0000000006534e80>" (String)
+#       With custom addition:     #<Foo:0x0000000006473bb8 @bar=0, @baz=1> (Foo)
 #
 module JSON
-  # If *object* is string-like, parse the string and return the parsed result as a
-  # Ruby data structure. Otherwise generate a JSON text from the Ruby data
-  # structure object and return it.
-  #
-  # The *opts* argument is passed through to generate/parse respectively. See
-  # generate and parse for their documentation.
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - JSON[object] -> new_array or new_string
+  # -->
+  # If `object` is a String, calls JSON.parse with `object` and `opts` (see method
+  # #parse):
+  #     json = '[0, 1, null]'
+  #     JSON[json]# => [0, 1, nil]
+  #
+  # Otherwise, calls JSON.generate with `object` and `opts` (see method
+  # #generate):
+  #     ruby = [0, 1, nil]
+  #     JSON[ruby] # => '[0,1,null]'
   #
   def self.[]: (untyped object, ?json_options opts) -> untyped
 
-  # This is create identifier, which is used to decide if the *json_create* hook
-  # of a class should be called. It defaults to 'json_class'.
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - create_id()
+  # -->
+  # Returns the current create identifier. See also JSON.create_id=.
   #
   def self.create_id: () -> _ToS
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - create_id=(new_value)
+  # -->
+  # 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'
+  #
   def self.create_id=: (_ToS create_id) -> _ToS
 
   def self.deep_const_get: (_ToS path) -> untyped
-  # Dumps *obj* as a JSON string, i.e. calls generate on the object and returns
+
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - JSON.dump(obj, io = nil, limit = nil)
+  # -->
+  # Dumps `obj` as a JSON string, i.e. calls generate on the object and returns
   # the result.
   #
-  # If anIO (an IO-like object or an object that responds to the write method) was
-  # given, the resulting JSON is written to it.
+  # The default options can be changed via method JSON.dump_default_options.
+  #
+  # *   Argument `io`, if given, should respond to method `write`; the JSON String
+  #     is written to `io`, and `io` is returned. If `io` is not given, the JSON
+  #     String is returned.
+  # *   Argument `limit`, if given, is passed to JSON.generate as option
+  #     `max_nesting`.
   #
-  # If the number of nested arrays or objects exceeds *limit*, an ArgumentError
-  # exception is raised. This argument is similar (but not exactly the same!) to
-  # the *limit* argument in Marshal.dump.
   #
-  # The default options for the generator can be changed via the
-  # dump_default_options method.
+  # ---
   #
-  # This method is part of the implementation of the load/dump interface of
-  # Marshal and YAML.
+  # When argument `io` is not given, returns the JSON String generated from `obj`:
+  #     obj = {foo: [0, 1], bar: {baz: 2, bat: 3}, bam: :bad}
+  #     json = JSON.dump(obj)
+  #     json # => "{\"foo\":[0,1],\"bar\":{\"baz\":2,\"bat\":3},\"bam\":\"bad\"}"
+  #
+  # When argument `io` is given, writes the JSON String to `io` and returns `io`:
+  #     path = 't.json'
+  #     File.open(path, 'w') do |file|
+  #       JSON.dump(obj, file)
+  #     end # => #<File:t.json (closed)>
+  #     puts File.read(path)
+  #
+  # Output:
+  #     {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"}
   #
   def self?.dump: (_ToJson obj, ?Integer limit) -> String
                 | (_ToJson obj, _JsonToWritableIO anIO) -> _JsonWrite
                 | (_ToJson obj, _JsonWrite anIO, ?Integer limit) -> _JsonWrite
 
-  # The global default options for the JSON.dump method:
-  #     :max_nesting: false
-  #     :allow_nan: true
-  #     :allow_blank: true
+  # <!-- rdoc-file=ext/json/lib/json/common.rb -->
+  # Sets or returns the default options for the JSON.dump method. Initially:
+  #     opts = JSON.dump_default_options
+  #     opts # => {:max_nesting=>false, :allow_nan=>true, :escape_slash=>false}
   #
   def self.dump_default_options: () -> json_options
 
+  # <!-- rdoc-file=ext/json/lib/json/common.rb -->
+  # Sets or returns the default options for the JSON.dump method. Initially:
+  #     opts = JSON.dump_default_options
+  #     opts # => {:max_nesting=>false, :allow_nan=>true, :escape_slash=>false}
+  #
   def self.dump_default_options=: (json_options) -> json_options
 
-  # Generate a JSON document from the Ruby data structure *obj* and return it.
-  # This method disables the checks for circles in Ruby objects.
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - JSON.fast_generate(obj, opts) -> new_string
+  # -->
+  # Arguments `obj` and `opts` here are the same as arguments `obj` and `opts` in
+  # JSON.generate.
   #
-  # **WARNING**: Be careful not to pass any Ruby data structures with circles as
-  # *obj* argument because this will cause JSON to go into an infinite loop.
+  # By default, generates JSON data without checking for circular references in
+  # `obj` (option `max_nesting` set to `false`, disabled).
+  #
+  # Raises an exception if `obj` contains circular references:
+  #     a = []; b = []; a.push(b); b.push(a)
+  #     # Raises SystemStackError (stack level too deep):
+  #     JSON.fast_generate(a)
   #
   def self?.fast_generate: (_ToJson obj, ?json_options opts) -> String
 
   alias self.fast_unparse self.fast_generate
+
   alias fast_unparse fast_generate
 
-  # Generate a JSON document from the Ruby data structure *obj* and return it.
-  # *state* is * a JSON::State object,
-  # *   or a Hash like object (responding to to_hash),
-  # *   an object convertible into a hash by a to_h method,
-  #
-  # that is used as or to configure a State object.
-  #
-  # It defaults to a state object, that creates the shortest possible JSON text in
-  # one line, checks for circular data structures and doesn't allow NaN, Infinity,
-  # and -Infinity.
-  #
-  # A *state* hash can have the following keys:
-  # *   **indent**: a string used to indent levels (default: ''),
-  # *   **space**: a string that is put after, a : or , delimiter (default: ''),
-  # *   **space_before**: a string that is put before a : pair delimiter (default:
-  #     ''),
-  # *   **object_nl**: a string that is put at the end of a JSON object (default:
-  #     ''),
-  # *   **array_nl**: a string that is put at the end of a JSON array (default:
-  #     ''),
-  # *   **allow_nan**: true if NaN, Infinity, and -Infinity should be generated,
-  #     otherwise an exception is thrown if these values are encountered. This
-  #     options defaults to false.
-  # *   **max_nesting**: The maximum depth of nesting allowed in the data
-  #     structures from which JSON is to be generated. Disable depth checking with
-  #     :max_nesting => false, it defaults to 100.
-  #
-  #
-  # See also the fast_generate for the fastest creation method with the least
-  # amount of sanity checks, and the pretty_generate method for some defaults for
-  # pretty output.
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - JSON.generate(obj, opts = nil) -> new_string
+  # -->
+  # Returns a String containing the generated JSON data.
+  #
+  # See also JSON.fast_generate, JSON.pretty_generate.
+  #
+  # Argument `obj` is the Ruby object to be converted to JSON.
+  #
+  # Argument `opts`, if given, contains a Hash of options for the generation. See
+  # [Generating Options](#module-JSON-label-Generating+Options).
+  #
+  # ---
+  #
+  # When `obj` is an Array, returns a String containing a JSON array:
+  #     obj = ["foo", 1.0, true, false, nil]
+  #     json = JSON.generate(obj)
+  #     json # => '["foo",1.0,true,false,null]'
+  #
+  # When `obj` is a Hash, returns a String containing a JSON object:
+  #     obj = {foo: 0, bar: 's', baz: :bat}
+  #     json = JSON.generate(obj)
+  #     json # => '{"foo":0,"bar":"s","baz":"bat"}'
+  #
+  # For examples of generating from other Ruby objects, see [Generating \JSON from
+  # Other Objects](#module-JSON-label-Generating+JSON+from+Other+Objects).
+  #
+  # ---
+  #
+  # Raises an exception if any formatting option is not a String.
+  #
+  # Raises an exception if `obj` contains circular references:
+  #     a = []; b = []; a.push(b); b.push(a)
+  #     # Raises JSON::NestingError (nesting of 100 is too deep):
+  #     JSON.generate(a)
   #
   def self?.generate: (_ToJson obj, ?json_options opts) -> String
 
+  # <!-- rdoc-file=ext/json/lib/json/common.rb -->
   # Returns the JSON generator module that is used by JSON. This is either
-  # JSON::Ext::Generator or JSON::Pure::Generator.
+  # JSON::Ext::Generator or JSON::Pure::Generator:
+  #     JSON.generator # => JSON::Ext::Generator
   #
   def self.generator: () -> json_generator
 
   def self.generator=: (json_generator generator) -> void
 
-  # Encodes string using Ruby's *String.encode*
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - iconv(to, from, string)
+  # -->
+  # Encodes string using String.encode.
   #
   def self.iconv: (encoding to, encoding from, String string) -> String
 
-  # Load a ruby data structure from a JSON *source* and return it. A source can
-  # either be a string-like object, an IO-like object, or an object responding to
-  # the read method. If *proc* was given, it will be called with any nested Ruby
-  # object as an argument recursively in depth first order. To modify the default
-  # options pass in the optional *options* argument as well.
-  #
-  # 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. The default
-  # options for the parser can be changed via the load_default_options method.
-  #
-  # This method is part of the implementation of the load/dump interface of
-  # Marshal and YAML.
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - JSON.load(source, proc = nil, options = {}) -> object
+  # -->
+  # Returns the Ruby objects created by parsing the given `source`.
+  #
+  # *   Argument `source` must be, or be convertible to, a String:
+  #     *   If `source` responds to instance method `to_str`, `source.to_str`
+  #         becomes the source.
+  #     *   If `source` responds to instance method `to_io`, `source.to_io.read`
+  #         becomes the source.
+  #     *   If `source` responds to instance method `read`, `source.read` becomes
+  #         the source.
+  #     *   If both of the following are true, source becomes the String `'null'`:
+  #         *   Option `allow_blank` specifies a truthy value.
+  #         *   The source, as defined above, is `nil` or the empty String `''`.
+  #
+  #     *   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. 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=.
+  #
+  #
+  # ---
+  #
+  # When no `proc` is given, modifies `source` as above and returns the result of
+  # `parse(source, opts)`;  see #parse.
+  #
+  # Source for following examples:
+  #     source = <<-EOT
+  #     {
+  #     "name": "Dave",
+  #       "age" :40,
+  #       "hats": [
+  #         "Cattleman's",
+  #         "Panama",
+  #         "Tophat"
+  #       ]
+  #     }
+  #     EOT
+  #
+  # Load a String:
+  #     ruby = JSON.load(source)
+  #     ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
+  #
+  # Load an IO object:
+  #     require 'stringio'
+  #     object = JSON.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.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 `parse(source, opts)`.
+  # *   Recursively calls `proc(result)`.
+  # *   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.load
+  #     ruby = JSON.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"}>}
   #
   def self?.load: (string | _JsonReadableIO | _JsonRead source, ?Proc proc, ?json_options options) -> untyped
 
-  # The global default options for the JSON.load method:
-  #     :max_nesting: false
-  #     :allow_nan: true
-  #     :allow_blank: true
+  # <!-- rdoc-file=ext/json/lib/json/common.rb -->
+  # 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}
   #
   def self.load_default_options: () -> json_options
 
+  # <!-- rdoc-file=ext/json/lib/json/common.rb -->
+  # 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}
+  #
   def self.load_default_options=: (json_options) -> json_options
 
-  # Parse the JSON document *source* into a Ruby data structure and return it.
-  #
-  # *opts* can have the following keys:
-  # *   **max_nesting**: The maximum depth of nesting allowed in the parsed data
-  #     structures. Disable depth checking with :max_nesting => false. It defaults
-  #     to 100.
-  # *   **allow_nan**: If set to true, allow NaN, Infinity and -Infinity in
-  #     defiance of RFC 7159 to be parsed by the Parser. This option defaults to
-  #     false.
-  # *   **symbolize_names**: If set to true, returns symbols for the names (keys)
-  #     in a JSON object. Otherwise strings are returned. Strings are the default.
-  # *   **create_additions**: If set to false, the Parser doesn't create additions
-  #     even if a matching class and create_id was found. This option defaults to
-  #     false.
-  # *   **object_class**: Defaults to Hash
-  # *   **array_class**: Defaults to Array
-  #
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - JSON.parse(source, opts) -> object
+  # -->
+  # Returns the Ruby objects created by parsing the given `source`.
+  #
+  # Argument `source` contains the String to be parsed.
+  #
+  # Argument `opts`, if given, contains a Hash of options for the parsing. See
+  # [Parsing Options](#module-JSON-label-Parsing+Options).
+  #
+  # ---
+  #
+  # When `source` is a JSON array, returns a Ruby Array:
+  #     source = '["foo", 1.0, true, false, null]'
+  #     ruby = JSON.parse(source)
+  #     ruby # => ["foo", 1.0, true, false, nil]
+  #     ruby.class # => Array
+  #
+  # When `source` is a JSON object, returns a Ruby Hash:
+  #     source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}'
+  #     ruby = JSON.parse(source)
+  #     ruby # => {"a"=>"foo", "b"=>1.0, "c"=>true, "d"=>false, "e"=>nil}
+  #     ruby.class # => Hash
+  #
+  # For examples of parsing for all JSON data types, see [Parsing
+  # \JSON](#module-JSON-label-Parsing+JSON).
+  #
+  # Parses nested JSON objects:
+  #     source = <<-EOT
+  #     {
+  #     "name": "Dave",
+  #       "age" :40,
+  #       "hats": [
+  #         "Cattleman's",
+  #         "Panama",
+  #         "Tophat"
+  #       ]
+  #     }
+  #     EOT
+  #     ruby = JSON.parse(source)
+  #     ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
+  #
+  # ---
+  #
+  # Raises an exception if `source` is not valid JSON:
+  #     # Raises JSON::ParserError (783: unexpected token at ''):
+  #     JSON.parse('')
   #
   def self?.parse: (string source, ?json_options opts) -> untyped
 
-  # Parse the JSON document *source* into a Ruby data structure and return it. The
-  # bang version of the parse method defaults to the more dangerous values for the
-  # *opts* hash, so be sure only to parse trusted *source* documents.
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - JSON.parse!(source, opts) -> object
+  # -->
+  # Calls
+  #     parse(source, opts)
   #
-  # *opts* can have the following keys:
-  # *   **max_nesting**: The maximum depth of nesting allowed in the parsed data
-  #     structures. Enable depth checking with :max_nesting => anInteger. The
-  #     parse! methods defaults to not doing max depth checking: This can be
-  #     dangerous if someone wants to fill up your stack.
-  # *   **allow_nan**: If set to true, allow NaN, Infinity, and -Infinity in
-  #     defiance of RFC 7159 to be parsed by the Parser. This option defaults to
-  #     true.
-  # *   **create_additions**: If set to false, the Parser doesn't create additions
-  #     even if a matching class and create_id was found. This option defaults to
-  #     false.
+  # with `source` and possibly modified `opts`.
   #
+  # Differences from JSON.parse:
+  # *   Option `max_nesting`, if not provided, defaults to `false`, which disables
+  #     checking for nesting depth.
+  # *   Option `allow_nan`, if not provided, defaults to `true`.
   #
   def self?.parse!: (string source, ?json_options opts) -> untyped
 
+  # <!-- rdoc-file=ext/json/lib/json/common.rb -->
   # Returns the JSON parser class that is used by JSON. This is either
-  # JSON::Ext::Parser or JSON::Pure::Parser.
+  # JSON::Ext::Parser or JSON::Pure::Parser:
+  #     JSON.parser # => JSON::Ext::Parser
   #
   def self.parser: () -> json_parser
 
   def self.parser=: (json_parser parser) -> void
 
-  # Generate a JSON document from the Ruby data structure *obj* and return it. The
-  # returned document is a prettier form of the document returned by #unparse.
-  #
-  # The *opts* argument can be used to configure the generator. See the generate
-  # method for a more detailed explanation.
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - JSON.pretty_generate(obj, opts = nil) -> new_string
+  # -->
+  # Arguments `obj` and `opts` here are the same as arguments `obj` and `opts` in
+  # JSON.generate.
+  #
+  # Default options are:
+  #     {
+  #       indent: '  ',   # Two spaces
+  #       space: ' ',     # One space
+  #       array_nl: "\n", # Newline
+  #       object_nl: "\n" # Newline
+  #     }
+  #
+  # Example:
+  #     obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}}
+  #     json = JSON.pretty_generate(obj)
+  #     puts json
+  #
+  # Output:
+  #     {
+  #       "foo": [
+  #         "bar",
+  #         "baz"
+  #       ],
+  #       "bat": {
+  #         "bam": 0,
+  #         "bad": 1
+  #       }
+  #     }
   #
   def self?.pretty_generate: (_ToJson obj, ?json_options opts) -> untyped
 
   alias self.pretty_unparse self.pretty_generate
+
   alias pretty_unparse pretty_generate
 
   # Recursively calls passed *Proc* if the parsed data structure is an *Array* or
@@ -300,17 +1104,36 @@ module JSON
   #
   def self?.recurse_proc: (untyped result) { (*untyped) -> void } -> void
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - restore(source, proc = nil, options = {})
+  # -->
+  #
   alias self.restore self.load
+
+  # <!--
+  #   rdoc-file=ext/json/lib/json/common.rb
+  #   - restore(source, proc = nil, options = {})
+  # -->
+  #
   alias restore load
 
-  # Returns the JSON generator state class that is used by JSON. This is either
-  # JSON::Ext::Generator::State or JSON::Pure::Generator::State.
+  # <!-- rdoc-file=ext/json/lib/json/common.rb -->
+  # 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
   #
   def self.state: () -> json_state
 
+  # <!-- rdoc-file=ext/json/lib/json/common.rb -->
+  # 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
+  #
   def self.state=: (json_state) -> json_state
 
   alias self.unparse self.generate
+
   alias unparse generate
 end
 
@@ -328,6 +1151,7 @@ JSON::PRETTY_STATE_PROTOTYPE: json_state
 
 JSON::SAFE_STATE_PROTOTYPE: json_state
 
+# <!-- rdoc-file=ext/json/lib/json/version.rb -->
 # JSON version
 #
 JSON::VERSION: String
@@ -340,6 +1164,7 @@ JSON::VERSION_MAJOR: Integer
 
 JSON::VERSION_MINOR: Integer
 
+%a{annotate:rdoc:skip}
 class Object
   # Converts this object to a string (calling #to_s), converts
   # it to a JSON string, and returns the result. This is a fallback, if no
@@ -348,24 +1173,28 @@ class Object
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class NilClass
   # Returns a JSON string for nil: 'null'.
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class TrueClass
   # Returns a JSON string for true: 'true'.
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class FalseClass
   # Returns a JSON string for false: 'false'.
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class String
   # This string should be encoded with UTF-8 A call to this method
   # returns a JSON string encoded with UTF16 big endian characters as
@@ -374,18 +1203,21 @@ class String
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Integer
   # Returns a JSON string representation for this Integer number.
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Float
   # Returns a JSON string representation for this Float number.
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Hash[unchecked out K, unchecked out V]
   # Returns a JSON string containing a JSON object, that is generated from
   # this Hash instance.
@@ -395,6 +1227,7 @@ class Hash[unchecked out K, unchecked out V]
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Array[unchecked out Elem]
   # Returns a JSON string containing a JSON array, that is generated from
   # this Array instance.
@@ -404,70 +1237,122 @@ class Array[unchecked out Elem]
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class BigDecimal
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/bigdecimal.rb
+  #   - json_create(object)
+  # -->
   # Import a JSON Marshalled object.
   #
   # method used for JSON marshalling support.
   #
   def self.json_create: (Hash[String, String] object) -> instance
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/bigdecimal.rb
+  #   - as_json(*)
+  # -->
   # Marshal the object to JSON.
   #
   # method used for JSON marshalling support.
   #
   def as_json: (*untyped) -> Hash[String, String]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/bigdecimal.rb
+  #   - to_json(*args)
+  # -->
   # return the JSON value
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Complex
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/complex.rb
+  #   - json_create(object)
+  # -->
   # Deserializes JSON string by converting Real value `r`, imaginary value `i`, to
   # a Complex object.
   #
   def self.json_create: (Hash[String, String | Numeric] object) -> instance
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/complex.rb
+  #   - as_json(*)
+  # -->
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
   #
   def as_json: (*untyped) -> Hash[String, String | Numeric]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/complex.rb
+  #   - to_json(*args)
+  # -->
   # Stores class name (Complex) along with real value `r` and imaginary value `i`
   # as JSON string
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Date
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/date.rb
+  #   - json_create(object)
+  # -->
   # Deserializes JSON string by converting Julian year `y`, month `m`, day `d` and
   # Day of Calendar Reform `sg` to Date.
   #
   def self.json_create: (Hash[String, String | Integer | Float] object) -> instance
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/date.rb
+  #   - as_json(*)
+  # -->
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
   #
   def as_json: (*untyped) -> Hash[String, String | Integer | Float]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/date.rb
+  #   - to_json(*args)
+  # -->
   # Stores class name (Date) with Julian year `y`, month `m`, day `d` and Day of
   # Calendar Reform `sg` as JSON string
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class DateTime
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/date_time.rb
+  #   - json_create(object)
+  # -->
   # Deserializes JSON string by converting year `y`, month `m`, day `d`, hour `H`,
   # minute `M`, second `S`, offset `of` and Day of Calendar Reform `sg` to
   # DateTime.
   #
   def self.json_create: (Hash[String, String | Integer | Float] object) -> instance
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/date_time.rb
+  #   - as_json(*)
+  # -->
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
   #
   def as_json: (*untyped) -> Hash[String, String | Integer | Float]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/date_time.rb
+  #   - to_json(*args)
+  # -->
   # Stores class name (DateTime) with Julian year `y`, month `m`, day `d`, hour
   # `H`, minute `M`, second `S`, offset `of` and Day of Calendar Reform `sg` as
   # JSON string
@@ -475,50 +1360,89 @@ class DateTime
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Exception
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/exception.rb
+  #   - json_create(object)
+  # -->
   # Deserializes JSON string by constructing new Exception object with message `m`
   # and backtrace `b` serialized with `to_json`
   #
   def self.json_create: (Hash[String, String | Array[String] | nil] object) -> instance
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/exception.rb
+  #   - as_json(*)
+  # -->
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
   #
   def as_json: (*untyped) -> Hash[String, String | Array[String] | nil]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/exception.rb
+  #   - to_json(*args)
+  # -->
   # Stores class name (Exception) with message `m` and backtrace array `b` as JSON
   # string
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class OpenStruct
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/ostruct.rb
+  #   - json_create(object)
+  # -->
   # Deserializes JSON string by constructing new Struct object with values `t`
   # serialized by `to_json`.
   #
   def self.json_create: (Hash[String, String | Hash[Symbol, untyped]] object) -> instance
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/ostruct.rb
+  #   - as_json(*)
+  # -->
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
   #
   def as_json: (*untyped) -> Hash[String, String | Hash[Symbol, untyped]]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/ostruct.rb
+  #   - to_json(*args)
+  # -->
   # Stores class name (OpenStruct) with this struct's values `t` as a JSON string.
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Range[out Elem]
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/range.rb
+  #   - json_create(object)
+  # -->
   # Deserializes JSON string by constructing new Range object with arguments `a`
   # serialized by `to_json`.
   #
-  def self.json_create: [A] (Hash[String, String | [A, A, bool]] object) -> Range[A]
+  def self.json_create: [A] (Hash[String, String | [ A, A, bool ]] object) -> Range[A]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/range.rb
+  #   - as_json(*)
+  # -->
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
   #
-  def as_json: (*untyped) -> Hash[String, String | [Elem, Elem, bool]]
+  def as_json: (*untyped) -> Hash[String, String | [ Elem, Elem, bool ]]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/range.rb
+  #   - to_json(*args)
+  # -->
   # Stores class name (Range) with JSON array of arguments `a` which include
   # `first` (integer), `last` (integer), and `exclude_end?` (boolean) as JSON
   # string.
@@ -526,102 +1450,180 @@ class Range[out Elem]
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Rational
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/rational.rb
+  #   - json_create(object)
+  # -->
   # Deserializes JSON string by converting numerator value `n`, denominator value
   # `d`, to a Rational object.
   #
   def self.json_create: (Hash[String, String | Integer] object) -> instance
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/rational.rb
+  #   - as_json(*)
+  # -->
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
   #
   def as_json: (*untyped) -> Hash[String, String | Integer]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/rational.rb
+  #   - to_json(*args)
+  # -->
   # Stores class name (Rational) along with numerator value `n` and denominator
   # value `d` as JSON string
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Regexp
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/regexp.rb
+  #   - json_create(object)
+  # -->
   # Deserializes JSON string by constructing new Regexp object with source `s`
   # (Regexp or String) and options `o` serialized by `to_json`
   #
   def self.json_create: (Hash[String, String | Integer] object) -> instance
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/regexp.rb
+  #   - as_json(*)
+  # -->
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
   #
   def as_json: (*untyped) -> Hash[String, String | Integer]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/regexp.rb
+  #   - to_json(*args)
+  # -->
   # Stores class name (Regexp) with options `o` and source `s` (Regexp or String)
   # as JSON string
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Set[A]
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/set.rb
+  #   - json_create(object)
+  # -->
   # Import a JSON Marshalled object.
   #
   # method used for JSON marshalling support.
   #
   def self.json_create: [A] (Hash[String, String | Array[A]] object) -> Set[A]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/set.rb
+  #   - as_json(*)
+  # -->
   # Marshal the object to JSON.
   #
   # method used for JSON marshalling support.
   #
   def as_json: (*untyped) -> Hash[String, String | Array[A]]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/set.rb
+  #   - to_json(*args)
+  # -->
   # return the JSON value
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Struct[Elem]
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/struct.rb
+  #   - json_create(object)
+  # -->
   # Deserializes JSON string by constructing new Struct object with values `v`
   # serialized by `to_json`.
   #
   def self.json_create: [Elem] (Hash[String, String | Array[Elem]] object) -> Struct[Elem]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/struct.rb
+  #   - as_json(*)
+  # -->
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
   #
   def as_json: (*untyped) -> Hash[String, String | Array[Elem]]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/struct.rb
+  #   - to_json(*args)
+  # -->
   # Stores class name (Struct) with Struct values `v` as a JSON string. Only named
   # structs are supported.
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Symbol
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/symbol.rb
+  #   - json_create(o)
+  # -->
   # Deserializes JSON string by converting the `string` value stored in the object
   # to a Symbol
   #
   def self.json_create: (Hash[String, String] object) -> instance
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/symbol.rb
+  #   - as_json(*)
+  # -->
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
   #
   def as_json: (*untyped) -> Hash[String, String]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/symbol.rb
+  #   - to_json(*a)
+  # -->
   # Stores class name (Symbol) with String representation of Symbol as a JSON
   # string.
   #
   def to_json: (?JSON::State state) -> String
 end
 
+%a{annotate:rdoc:skip}
 class Time
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/time.rb
+  #   - json_create(object)
+  # -->
   # Deserializes JSON string by converting time since epoch to Time
   #
   def self.json_create: (Hash[String, String | Integer] object) -> instance
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/time.rb
+  #   - as_json(*)
+  # -->
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
   #
   def as_json: (*untyped) -> Hash[String, String | Integer]
 
+  # <!--
+  #   rdoc-file=ext/json/lib/json/add/time.rb
+  #   - to_json(*args)
+  # -->
   # Stores class name (Time) with number of seconds since epoch and number of
   # microseconds for Time as JSON string
   #