@ai-ecoverse/wasix-ruby 3.4.11-2 → 3.4.11-3

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/stdlib/json/0/json.rbs

@@ -1,1914 +0,0 @@
-interface _ToJson
-  def to_json: (?JSON::State state) -> String
-end
-
-interface _JsonToWritableIO
-  def to_io: () -> _JsonWrite
-end
-
-interface _JsonWrite
-  def write: (String json) -> void
-
-  def flush: () -> void
-end
-
-interface _JsonReadableIO
-  def to_io: () -> _JsonRead
-end
-
-interface _JsonRead
-  def read: () -> string
-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
-#
-#     JSON.generator = JSON::Ext::Generator
-#
-# with the method generator= in JSON.
-#
-module JSON::Ext::Generator
-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
-
-module JSON::Pure
-end
-
-module JSON::Pure::Generator
-end
-
-class JSON::Pure::Generator::State
-end
-
-class JSON::Pure::Parser
-end
-
-type json_generator = singleton(::JSON::Ext::Generator) | singleton(::JSON::Pure::Generator)
-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.
-#
-# 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]
-#
-# *   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}
-#
-# 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'
-#
-# All examples here assume that this has been done.
-#
-# ### Parsing JSON
-#
-# You can parse a String containing JSON data using either of two methods:
-# *   `JSON.parse(source, opts)`
-# *   `JSON.parse!(source, opts)`
-#
-# where
-# *   `source` is a Ruby object.
-# *   `opts` is a Hash object containing options that control both input allowed
-#     and output formatting.
-#
-# 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.
-#
-# #### Parsing JSON Arrays
-#
-# 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`.
-#
-# 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)
-#
-# ###### Escaping Options
-#
-# Options `script_safe` (boolean) specifies wether `'\u2028'`, `'\u2029'` and
-# `'/'` should be escaped as to make the JSON object safe to interpolate in
-# script tags.
-#
-# Options `ascii_only` (boolean) specifies wether all characters outside the
-# ASCII range should be escaped.
-#
-# ###### 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:
-#
-#     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
-  # <!--
-  #   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
-
-  # <!--
-  #   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: (interned path) -> untyped
-
-  # <!--
-  #   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.
-  #
-  # 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`.
-  #
-  # ---
-  #
-  # 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
-
-  # <!-- 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}
-  #
-  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}
-  #
-  def self.dump_default_options=: (json_options) -> json_options
-
-  # <!--
-  #   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.
-  #
-  # 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
-
-  # <!--
-  #   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.
-  #
-  def self.generator: () -> json_generator
-
-  def self.generator=: (json_generator generator) -> void
-
-  # <!--
-  #   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
-
-  # <!--
-  #   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`.
-  #
-  # 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`, `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.
-  # *   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 = <<~JSON
-  #       {
-  #         "name": "Dave",
-  #         "age" :40,
-  #         "hats": [
-  #           "Cattleman's",
-  #           "Panama",
-  #           "Tophat"
-  #         ]
-  #       }
-  #     JSON
-  #
-  # 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
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/common.rb
-  #   - JSON.load_file(path, opts={}) -> object
-  # -->
-  # Calls:
-  #     parse(File.read(path), opts)
-  #
-  # See method #parse.
-  #
-  def self?.load_file: (string path, ?json_options opts) -> untyped
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/common.rb
-  #   - JSON.load_file!(path, opts = {})
-  # -->
-  # Calls:
-  #     JSON.parse!(File.read(path, opts))
-  #
-  # See method #parse!
-  #
-  def self?.load_file!: (string path, ?json_options opts) -> untyped
-
-  # <!-- 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
-
-  # <!--
-  #   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 = <<~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"]}
-  #
-  # ---
-  #
-  # 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
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/common.rb
-  #   - JSON.parse!(source, opts) -> object
-  # -->
-  # Calls
-  #     parse(source, opts)
-  #
-  # 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.
-  #
-  def self.parser: () -> json_parser
-
-  def self.parser=: (json_parser parser) -> void
-
-  # <!--
-  #   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
-  # *Hash*
-  #
-  def self?.recurse_proc: (untyped result) { (*untyped) -> void } -> void
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/common.rb
-  #   - restore(source, proc = nil, options = nil)
-  # -->
-  #
-  alias self.restore self.load
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/common.rb
-  #   - restore(source, proc = nil, options = nil)
-  # -->
-  #
-  alias restore load
-
-  # <!-- rdoc-file=ext/json/lib/json/common.rb -->
-  # Sets or Returns the JSON generator state class that is used by JSON.
-  #
-  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.
-  #
-  def self.state=: (json_state) -> json_state
-
-  alias self.unparse self.generate
-
-  alias unparse generate
-end
-
-JSON::FAST_STATE_PROTOTYPE: json_state
-
-JSON::Infinity: Float
-
-JSON::JSON_LOADED: bool
-
-JSON::MinusInfinity: Float
-
-JSON::NaN: Float
-
-JSON::PRETTY_STATE_PROTOTYPE: json_state
-
-JSON::SAFE_STATE_PROTOTYPE: json_state
-
-JSON::VERSION: String
-
-JSON::VERSION_ARRAY: Array[Integer]
-
-JSON::VERSION_BUILD: Integer
-
-JSON::VERSION_MAJOR: Integer
-
-JSON::VERSION_MINOR: Integer
-
-%a{annotate:rdoc:skip}
-module Kernel
-  private
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/common.rb
-  #   - j(*objs)
-  # -->
-  # Outputs *objs* to STDOUT as JSON strings in the shortest form, that is in one
-  # line.
-  #
-  def j: (*_ToJson) -> nil
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/common.rb
-  #   - jj(*objs)
-  # -->
-  # Outputs *objs* to STDOUT as JSON strings in a pretty format, with indentation
-  # and over many lines.
-  #
-  def jj: (*_ToJson) -> nil
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/common.rb
-  #   - JSON(object, *args)
-  # -->
-  # 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.
-  #
-  def JSON: (string source, ?json_options opts) -> untyped
-          | (_ToJson obj, ?json_options opts) -> String
-end
-
-%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
-  # special method #to_json was defined for some 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
-  # \u????.
-  #
-  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.
-  # _state_ is a JSON::State object, that can also be used to configure the
-  # produced JSON string output further.
-  #
-  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.
-  # _state_ is a JSON::State object, that can also be used to configure the
-  # produced JSON string output further.
-  #
-  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)
-  # -->
-  # See #as_json.
-  #
-  def self.json_create: (Hash[String, String] object) -> instance
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/bigdecimal.rb
-  #   - as_json(*)
-  # -->
-  # Methods `BigDecimal#as_json` and `BigDecimal.json_create` may be used to
-  # serialize and deserialize a BigDecimal object; see
-  # [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `BigDecimal#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/bigdecimal'
-  #     x = BigDecimal(2).as_json             # => {"json_class"=>"BigDecimal", "b"=>"27:0.2e1"}
-  #     y = BigDecimal(2.0, 4).as_json        # => {"json_class"=>"BigDecimal", "b"=>"36:0.2e1"}
-  #     z = BigDecimal(Complex(2, 0)).as_json # => {"json_class"=>"BigDecimal", "b"=>"27:0.2e1"}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a BigDecimal object:
-  #
-  #     BigDecimal.json_create(x) # => 0.2e1
-  #     BigDecimal.json_create(y) # => 0.2e1
-  #     BigDecimal.json_create(z) # => 0.2e1
-  #
-  def as_json: (*untyped) -> Hash[String, String]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/bigdecimal.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/bigdecimal'
-  #     puts BigDecimal(2).to_json
-  #     puts BigDecimal(2.0, 4).to_json
-  #     puts BigDecimal(Complex(2, 0)).to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"BigDecimal","b":"27:0.2e1"}
-  #     {"json_class":"BigDecimal","b":"36:0.2e1"}
-  #     {"json_class":"BigDecimal","b":"27:0.2e1"}
-  #
-  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)
-  # -->
-  # See #as_json.
-  #
-  def self.json_create: (Hash[String, String | Numeric] object) -> instance
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/complex.rb
-  #   - as_json(*)
-  # -->
-  # Methods `Complex#as_json` and `Complex.json_create` may be used to serialize
-  # and deserialize a Complex object; see [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `Complex#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/complex'
-  #     x = Complex(2).as_json      # => {"json_class"=>"Complex", "r"=>2, "i"=>0}
-  #     y = Complex(2.0, 4).as_json # => {"json_class"=>"Complex", "r"=>2.0, "i"=>4}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a Complex object:
-  #
-  #     Complex.json_create(x) # => (2+0i)
-  #     Complex.json_create(y) # => (2.0+4i)
-  #
-  def as_json: (*untyped) -> Hash[String, String | Numeric]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/complex.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/complex'
-  #     puts Complex(2).to_json
-  #     puts Complex(2.0, 4).to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"Complex","r":2,"i":0}
-  #     {"json_class":"Complex","r":2.0,"i":4}
-  #
-  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)
-  # -->
-  # See #as_json.
-  #
-  def self.json_create: (Hash[String, String | Integer | Float] object) -> instance
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/date.rb
-  #   - as_json(*)
-  # -->
-  # Methods `Date#as_json` and `Date.json_create` may be used to serialize and
-  # deserialize a Date object; see [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `Date#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/date'
-  #     x = Date.today.as_json
-  #     # => {"json_class"=>"Date", "y"=>2023, "m"=>11, "d"=>21, "sg"=>2299161.0}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a Date object:
-  #
-  #     Date.json_create(x)
-  #     # => #<Date: 2023-11-21 ((2460270j,0s,0n),+0s,2299161j)>
-  #
-  def as_json: (*untyped) -> Hash[String, String | Integer | Float]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/date.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/date'
-  #     puts Date.today.to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"Date","y":2023,"m":11,"d":21,"sg":2299161.0}
-  #
-  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)
-  # -->
-  # See #as_json.
-  #
-  def self.json_create: (Hash[String, String | Integer | Float] object) -> instance
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/date_time.rb
-  #   - as_json(*)
-  # -->
-  # Methods `DateTime#as_json` and `DateTime.json_create` may be used to serialize
-  # and deserialize a DateTime object; see [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `DateTime#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/datetime'
-  #     x = DateTime.now.as_json
-  #     # => {"json_class"=>"DateTime", "y"=>2023, "m"=>11, "d"=>21, "sg"=>2299161.0}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a DateTime object:
-  #
-  #     DateTime.json_create(x) # BUG? Raises Date::Error "invalid date"
-  #
-  def as_json: (*untyped) -> Hash[String, String | Integer | Float]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/date_time.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/datetime'
-  #     puts DateTime.now.to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"DateTime","y":2023,"m":11,"d":21,"sg":2299161.0}
-  #
-  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)
-  # -->
-  # See #as_json.
-  #
-  def self.json_create: (Hash[String, String | Array[String] | nil] object) -> instance
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/exception.rb
-  #   - as_json(*)
-  # -->
-  # Methods `Exception#as_json` and `Exception.json_create` may be used to
-  # serialize and deserialize a Exception object; see [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `Exception#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/exception'
-  #     x = Exception.new('Foo').as_json # => {"json_class"=>"Exception", "m"=>"Foo", "b"=>nil}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a Exception object:
-  #
-  #     Exception.json_create(x) # => #<Exception: Foo>
-  #
-  def as_json: (*untyped) -> Hash[String, String | Array[String] | nil]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/exception.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/exception'
-  #     puts Exception.new('Foo').to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"Exception","m":"Foo","b":null}
-  #
-  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)
-  # -->
-  # See #as_json.
-  #
-  def self.json_create: (Hash[String, String | Hash[Symbol, untyped]] object) -> instance
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/ostruct.rb
-  #   - as_json(*)
-  # -->
-  # Methods `OpenStruct#as_json` and `OpenStruct.json_create` may be used to
-  # serialize and deserialize a OpenStruct object; see
-  # [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `OpenStruct#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/ostruct'
-  #     x = OpenStruct.new('name' => 'Rowdy', :age => nil).as_json
-  #     # => {"json_class"=>"OpenStruct", "t"=>{:name=>'Rowdy', :age=>nil}}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a OpenStruct object:
-  #
-  #     OpenStruct.json_create(x)
-  #     # => #<OpenStruct name='Rowdy', age=nil>
-  #
-  def as_json: (*untyped) -> Hash[String, String | Hash[Symbol, untyped]]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/ostruct.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/ostruct'
-  #     puts OpenStruct.new('name' => 'Rowdy', :age => nil).to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"OpenStruct","t":{'name':'Rowdy',"age":null}}
-  #
-  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)
-  # -->
-  # See #as_json.
-  #
-  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(*)
-  # -->
-  # Methods `Range#as_json` and `Range.json_create` may be used to serialize and
-  # deserialize a Range object; see [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `Range#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/range'
-  #     x = (1..4).as_json     # => {"json_class"=>"Range", "a"=>[1, 4, false]}
-  #     y = (1...4).as_json    # => {"json_class"=>"Range", "a"=>[1, 4, true]}
-  #     z = ('a'..'d').as_json # => {"json_class"=>"Range", "a"=>["a", "d", false]}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a Range object:
-  #
-  #     Range.json_create(x) # => 1..4
-  #     Range.json_create(y) # => 1...4
-  #     Range.json_create(z) # => "a".."d"
-  #
-  def as_json: (*untyped) -> Hash[String, String | [ Elem, Elem, bool ]]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/range.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/range'
-  #     puts (1..4).to_json
-  #     puts (1...4).to_json
-  #     puts ('a'..'d').to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"Range","a":[1,4,false]}
-  #     {"json_class":"Range","a":[1,4,true]}
-  #     {"json_class":"Range","a":["a","d",false]}
-  #
-  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)
-  # -->
-  # See #as_json.
-  #
-  def self.json_create: (Hash[String, String | Integer] object) -> instance
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/rational.rb
-  #   - as_json(*)
-  # -->
-  # Methods `Rational#as_json` and `Rational.json_create` may be used to serialize
-  # and deserialize a Rational object; see [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `Rational#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/rational'
-  #     x = Rational(2, 3).as_json
-  #     # => {"json_class"=>"Rational", "n"=>2, "d"=>3}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a Rational object:
-  #
-  #     Rational.json_create(x)
-  #     # => (2/3)
-  #
-  def as_json: (*untyped) -> Hash[String, String | Integer]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/rational.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/rational'
-  #     puts Rational(2, 3).to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"Rational","n":2,"d":3}
-  #
-  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)
-  # -->
-  # See #as_json.
-  #
-  def self.json_create: (Hash[String, String | Integer] object) -> instance
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/regexp.rb
-  #   - as_json(*)
-  # -->
-  # Methods `Regexp#as_json` and `Regexp.json_create` may be used to serialize and
-  # deserialize a Regexp object; see [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `Regexp#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/regexp'
-  #     x = /foo/.as_json
-  #     # => {"json_class"=>"Regexp", "o"=>0, "s"=>"foo"}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a Regexp object:
-  #
-  #     Regexp.json_create(x) # => /foo/
-  #
-  def as_json: (*untyped) -> Hash[String, String | Integer]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/regexp.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/regexp'
-  #     puts /foo/.to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"Regexp","o":0,"s":"foo"}
-  #
-  def to_json: (?JSON::State state) -> String
-end
-
-%a{annotate:rdoc:skip}
-class Set[unchecked out A]
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/set.rb
-  #   - json_create(object)
-  # -->
-  # See #as_json.
-  #
-  def self.json_create: [A] (Hash[String, String | Array[A]] object) -> Set[A]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/set.rb
-  #   - as_json(*)
-  # -->
-  # Methods `Set#as_json` and `Set.json_create` may be used to serialize and
-  # deserialize a Set object; see [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `Set#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/set'
-  #     x = Set.new(%w/foo bar baz/).as_json
-  #     # => {"json_class"=>"Set", "a"=>["foo", "bar", "baz"]}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a Set object:
-  #
-  #     Set.json_create(x) # => #<Set: {"foo", "bar", "baz"}>
-  #
-  def as_json: (*untyped) -> Hash[String, String | Array[A]]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/set.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/set'
-  #     puts Set.new(%w/foo bar baz/).to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"Set","a":["foo","bar","baz"]}
-  #
-  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)
-  # -->
-  # See #as_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(*)
-  # -->
-  # Methods `Struct#as_json` and `Struct.json_create` may be used to serialize and
-  # deserialize a Struct object; see [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `Struct#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/struct'
-  #     Customer = Struct.new('Customer', :name, :address, :zip)
-  #     x = Struct::Customer.new.as_json
-  #     # => {"json_class"=>"Struct::Customer", "v"=>[nil, nil, nil]}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a Struct object:
-  #
-  #     Struct::Customer.json_create(x)
-  #     # => #<struct Struct::Customer name=nil, address=nil, zip=nil>
-  #
-  def as_json: (*untyped) -> Hash[String, String | Array[Elem]]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/struct.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/struct'
-  #     Customer = Struct.new('Customer', :name, :address, :zip)
-  #     puts Struct::Customer.new.to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"Struct","t":{'name':'Rowdy',"age":null}}
-  #
-  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)
-  # -->
-  # See #as_json.
-  #
-  def self.json_create: (Hash[String, String] object) -> instance
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/symbol.rb
-  #   - as_json(*)
-  # -->
-  # Methods `Symbol#as_json` and `Symbol.json_create` may be used to serialize and
-  # deserialize a Symbol object; see [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `Symbol#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/symbol'
-  #     x = :foo.as_json
-  #     # => {"json_class"=>"Symbol", "s"=>"foo"}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a Symbol object:
-  #
-  #     Symbol.json_create(x) # => :foo
-  #
-  def as_json: (*untyped) -> Hash[String, String]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/symbol.rb
-  #   - to_json(*a)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/symbol'
-  #     puts :foo.to_json
-  #
-  # Output:
-  #
-  #     # {"json_class":"Symbol","s":"foo"}
-  #
-  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)
-  # -->
-  # See #as_json.
-  #
-  def self.json_create: (Hash[String, String | Integer] object) -> instance
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/time.rb
-  #   - as_json(*)
-  # -->
-  # Methods `Time#as_json` and `Time.json_create` may be used to serialize and
-  # deserialize a Time object; see [Marshal](rdoc-ref:Marshal).
-  #
-  # Method `Time#as_json` serializes `self`, returning a 2-element hash
-  # representing `self`:
-  #
-  #     require 'json/add/time'
-  #     x = Time.now.as_json
-  #     # => {"json_class"=>"Time", "s"=>1700931656, "n"=>472846644}
-  #
-  # Method `JSON.create` deserializes such a hash, returning a Time object:
-  #
-  #     Time.json_create(x)
-  #     # => 2023-11-25 11:00:56.472846644 -0600
-  #
-  def as_json: (*untyped) -> Hash[String, String | Integer]
-
-  # <!--
-  #   rdoc-file=ext/json/lib/json/add/time.rb
-  #   - to_json(*args)
-  # -->
-  # Returns a JSON string representing `self`:
-  #
-  #     require 'json/add/time'
-  #     puts Time.now.to_json
-  #
-  # Output:
-  #
-  #     {"json_class":"Time","s":1700931678,"n":980650786}
-  #
-  def to_json: (?JSON::State state) -> String
-end