steep 0.16.0 → 0.17.1

data/vendor/ruby-signature/stdlib/builtin/proc.rbs

@@ -1,429 +0,0 @@
-# A `Proc` object is an encapsulation of a block of code, which can be
-# stored in a local variable, passed to a method or another
-# [Proc](Proc), and can be called.
-# [Proc](Proc) is an essential concept in Ruby and a
-# core of its functional programming features.
-# 
-# ```ruby
-# square = Proc.new {|x| x**2 }
-# 
-# square.call(3)  #=> 9
-# # shorthands:
-# square.(3)      #=> 9
-# square[3]       #=> 9
-# ```
-# 
-# [Proc](Proc) objects are *closures* , meaning they
-# remember and can use the entire context in which they were created.
-# 
-# ```ruby
-# def gen_times(factor)
-#   Proc.new {|n| n*factor } # remembers the value of factor at the moment of creation
-# end
-# 
-# times3 = gen_times(3)
-# times5 = gen_times(5)
-# 
-# times3.call(12)               #=> 36
-# times5.call(5)                #=> 25
-# times3.call(times5.call(4))   #=> 60
-# ```
-# 
-# 
-# There are several methods to create a [Proc](Proc)
-# 
-#   - Use the [Proc](Proc) class constructor:
-# 
-#     ```ruby
-#     proc1 = Proc.new {|x| x**2 }
-#     ```
-# 
-#   - Use the
-#     [Kernel\#proc](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-proc)
-#     method as a shorthand of
-#     [::new](Proc#method-c-new):
-# 
-#     ```ruby
-#     proc2 = proc {|x| x**2 }
-#     ```
-# 
-#   - Receiving a block of code into proc argument (note the `&` ):
-# 
-#     ```ruby
-#     def make_proc(&block)
-#       block
-#     end
-# 
-#     proc3 = make_proc {|x| x**2 }
-#     ```
-# 
-#   - Construct a proc with lambda semantics using the
-#     [Kernel\#lambda](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-lambda)
-#     method (see below for explanations about lambdas):
-# 
-#     ```ruby
-#     lambda1 = lambda {|x| x**2 }
-#     ```
-# 
-#   - Use the Lambda literal syntax (also constructs a proc with lambda
-#     semantics):
-# 
-#     ```ruby
-#     lambda2 = ->(x) { x**2 }
-#     ```
-# 
-# 
-# Procs are coming in two flavors: lambda and non-lambda (regular procs).
-# Differences are:
-# 
-#   - In lambdas, `return` means exit from this lambda;
-# 
-#   - In regular procs, `return` means exit from embracing method (and
-#     will throw `LocalJumpError` if invoked outside the method);
-# 
-#   - In lambdas, arguments are treated in the same way as in methods:
-#     strict, with `ArgumentError` for mismatching argument number, and no
-#     additional argument processing;
-# 
-#   - Regular procs accept arguments more generously: missing arguments
-#     are filled with `nil`, single
-#     [Array](https://ruby-doc.org/core-2.6.3/Array.html) arguments are
-#     deconstructed if the proc has multiple arguments, and there is no
-#     error raised on extra arguments.
-# 
-# Examples:
-# 
-# ```ruby
-# p = proc {|x, y| "x=#{x}, y=#{y}" }
-# p.call(1, 2)      #=> "x=1, y=2"
-# p.call([1, 2])    #=> "x=1, y=2", array deconstructed
-# p.call(1, 2, 8)   #=> "x=1, y=2", extra argument discarded
-# p.call(1)         #=> "x=1, y=", nil substituted instead of error
-# 
-# l = lambda {|x, y| "x=#{x}, y=#{y}" }
-# l.call(1, 2)      #=> "x=1, y=2"
-# l.call([1, 2])    # ArgumentError: wrong number of arguments (given 1, expected 2)
-# l.call(1, 2, 8)   # ArgumentError: wrong number of arguments (given 3, expected 2)
-# l.call(1)         # ArgumentError: wrong number of arguments (given 1, expected 2)
-# 
-# def test_return
-#   -> { return 3 }.call      # just returns from lambda into method body
-#   proc { return 4 }.call    # returns from method
-#   return 5
-# end
-# 
-# test_return # => 4, return from proc
-# ```
-# 
-# Lambdas are useful as self-sufficient functions, in particular useful as
-# arguments to higher-order functions, behaving exactly like Ruby methods.
-# 
-# Procs are useful for implementing iterators:
-# 
-# ```ruby
-# def test
-#   [[1, 2], [3, 4], [5, 6]].map {|a, b| return a if a + b > 10 }
-#                             #  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-# end
-# ```
-# 
-# Inside `map`, the block of code is treated as a regular (non-lambda)
-# proc, which means that the internal arrays will be deconstructed to
-# pairs of arguments, and `return` will exit from the method `test` . That
-# would not be possible with a stricter lambda.
-# 
-# You can tell a lambda from a regular proc by using the
-# [lambda?](Proc#method-i-lambda-3F) instance method.
-# 
-# Lambda semantics is typically preserved during the proc lifetime,
-# including `&` -deconstruction to a block of code:
-# 
-# ```ruby
-# p = proc {|x, y| x }
-# l = lambda {|x, y| x }
-# [[1, 2], [3, 4]].map(&p) #=> [1, 2]
-# [[1, 2], [3, 4]].map(&l) # ArgumentError: wrong number of arguments (given 1, expected 2)
-# ```
-# 
-# The only exception is dynamic method definition: even if defined by
-# passing a non-lambda proc, methods still have normal semantics of
-# argument checking.
-# 
-# ```ruby
-# class C
-#   define_method(:e, &proc {})
-# end
-# C.new.e(1,2)       #=> ArgumentError
-# C.new.method(:e).to_proc.lambda?   #=> true
-# ```
-# 
-# This exception ensures that methods never have unusual argument passing
-# conventions, and makes it easy to have wrappers defining methods that
-# behave as usual.
-# 
-# ```ruby
-# class C
-#   def self.def2(name, &body)
-#     define_method(name, &body)
-#   end
-# 
-#   def2(:f) {}
-# end
-# C.new.f(1,2)       #=> ArgumentError
-# ```
-# 
-# The wrapper *def2* receives `body` as a non-lambda proc, yet defines a
-# method which has normal semantics.
-# 
-# 
-# Any object that implements the `to_proc` method can be converted into a
-# proc by the `&` operator, and therefore con be consumed by iterators.
-# 
-# ```ruby
-# class Greater
-#   def initialize(greating)
-#     @greating = greating
-#   end
-# 
-#   def to_proc
-#     proc {|name| "#{@greating}, #{name}!" }
-#   end
-# end
-# 
-# hi = Greater.new("Hi")
-# hey = Greater.new("Hey")
-# ["Bob", "Jane"].map(&hi)    #=> ["Hi, Bob!", "Hi, Jane!"]
-# ["Bob", "Jane"].map(&hey)   #=> ["Hey, Bob!", "Hey, Jane!"]
-# ```
-# 
-# Of the Ruby core classes, this method is implemented by
-# [Symbol](https://ruby-doc.org/core-2.6.3/Symbol.html),
-# [Method](https://ruby-doc.org/core-2.6.3/Method.html), and
-# [Hash](https://ruby-doc.org/core-2.6.3/Hash.html).
-# 
-#     :to_s.to_proc.call(1)           #=> "1"
-#     [1, 2].map(&:to_s)              #=> ["1", "2"]
-# 
-#     method(:puts).to_proc.call(1)   # prints 1
-#     [1, 2].each(&method(:puts))     # prints 1, 2
-# 
-#     {test: 1}.to_proc.call(:test)       #=> 1
-#     %i[test many keys].map(&{test: 1})  #=> [1, nil, nil]
-class Proc < Object
-  # Returns the number of mandatory arguments. If the block is declared to
-  # take no arguments, returns 0. If the block is known to take exactly n
-  # arguments, returns n. If the block has optional arguments, returns -n-1,
-  # where n is the number of mandatory arguments, with the exception for
-  # blocks that are not lambdas and have only a finite number of optional
-  # arguments; in this latter case, returns n. Keyword arguments will be
-  # considered as a single additional argument, that argument being
-  # mandatory if any keyword argument is mandatory. A `proc` with no
-  # argument declarations is the same as a block declaring `||` as its
-  # arguments.
-  # 
-  #     proc {}.arity                  #=>  0
-  #     proc { || }.arity              #=>  0
-  #     proc { |a| }.arity             #=>  1
-  #     proc { |a, b| }.arity          #=>  2
-  #     proc { |a, b, c| }.arity       #=>  3
-  #     proc { |*a| }.arity            #=> -1
-  #     proc { |a, *b| }.arity         #=> -2
-  #     proc { |a, *b, c| }.arity      #=> -3
-  #     proc { |x:, y:, z:0| }.arity   #=>  1
-  #     proc { |*a, x:, y:0| }.arity   #=> -2
-  # 
-  #     proc   { |a=0| }.arity         #=>  0
-  #     lambda { |a=0| }.arity         #=> -1
-  #     proc   { |a=0, b| }.arity      #=>  1
-  #     lambda { |a=0, b| }.arity      #=> -2
-  #     proc   { |a=0, b=0| }.arity    #=>  0
-  #     lambda { |a=0, b=0| }.arity    #=> -1
-  #     proc   { |a, b=0| }.arity      #=>  1
-  #     lambda { |a, b=0| }.arity      #=> -2
-  #     proc   { |(a, b), c=0| }.arity #=>  1
-  #     lambda { |(a, b), c=0| }.arity #=> -2
-  #     proc   { |a, x:0, y:0| }.arity #=>  1
-  #     lambda { |a, x:0, y:0| }.arity #=> -2
-  def arity: () -> Integer
-
-  # Returns the binding associated with *prc* .
-  # 
-  # ```ruby
-  # def fred(param)
-  #   proc {}
-  # end
-  # 
-  # b = fred(99)
-  # eval("param", b.binding)   #=> 99
-  # ```
-  def binding: () -> Binding
-
-  def call: (*untyped arg0) -> untyped
-
-  def []: (*untyped arg0) -> untyped
-
-  def curry: (?Integer arity) -> Proc
-
-  # Returns a hash value corresponding to proc body.
-  # 
-  # See also Object\#hash.
-  def hash: () -> Integer
-
-  def initialize: () -> void
-                | () { (*untyped) -> untyped } -> void
-
-  # Returns `true` for a [Proc](Proc.downloaded.ruby_doc) object for which
-  # argument handling is rigid. Such procs are typically generated by
-  # `lambda` .
-  # 
-  # A [Proc](Proc.downloaded.ruby_doc) object generated by `proc` ignores
-  # extra arguments.
-  # 
-  # ```ruby
-  # proc {|a,b| [a,b] }.call(1,2,3)    #=> [1,2]
-  # ```
-  # 
-  # It provides `nil` for missing arguments.
-  # 
-  # ```ruby
-  # proc {|a,b| [a,b] }.call(1)        #=> [1,nil]
-  # ```
-  # 
-  # It expands a single array argument.
-  # 
-  # ```ruby
-  # proc {|a,b| [a,b] }.call([1,2])    #=> [1,2]
-  # ```
-  # 
-  # A [Proc](Proc.downloaded.ruby_doc) object generated by `lambda` doesn’t
-  # have such tricks.
-  # 
-  # ```ruby
-  # lambda {|a,b| [a,b] }.call(1,2,3)  #=> ArgumentError
-  # lambda {|a,b| [a,b] }.call(1)      #=> ArgumentError
-  # lambda {|a,b| [a,b] }.call([1,2])  #=> ArgumentError
-  # ```
-  # 
-  # [\#lambda?](Proc.downloaded.ruby_doc#method-i-lambda-3F) is a predicate
-  # for the tricks. It returns `true` if no tricks apply.
-  # 
-  # ```ruby
-  # lambda {}.lambda?            #=> true
-  # proc {}.lambda?              #=> false
-  # ```
-  # 
-  # [::new](Proc.downloaded.ruby_doc#method-c-new) is the same as `proc` .
-  # 
-  # ```ruby
-  # Proc.new {}.lambda?          #=> false
-  # ```
-  # 
-  # `lambda`, `proc` and [::new](Proc.downloaded.ruby_doc#method-c-new)
-  # preserve the tricks of a [Proc](Proc.downloaded.ruby_doc) object given
-  # by `&` argument.
-  # 
-  # ```ruby
-  # lambda(&lambda {}).lambda?   #=> true
-  # proc(&lambda {}).lambda?     #=> true
-  # Proc.new(&lambda {}).lambda? #=> true
-  # 
-  # lambda(&proc {}).lambda?     #=> false
-  # proc(&proc {}).lambda?       #=> false
-  # Proc.new(&proc {}).lambda?   #=> false
-  # ```
-  # 
-  # A [Proc](Proc.downloaded.ruby_doc) object generated by `&` argument has
-  # the tricks
-  # 
-  # ```ruby
-  # def n(&b) b.lambda? end
-  # n {}                         #=> false
-  # ```
-  # 
-  # The `&` argument preserves the tricks if a
-  # [Proc](Proc.downloaded.ruby_doc) object is given by `&` argument.
-  # 
-  # ```ruby
-  # n(&lambda {})                #=> true
-  # n(&proc {})                  #=> false
-  # n(&Proc.new {})              #=> false
-  # ```
-  # 
-  # A [Proc](Proc.downloaded.ruby_doc) object converted from a method has no
-  # tricks.
-  # 
-  # ```ruby
-  # def m() end
-  # method(:m).to_proc.lambda?   #=> true
-  # 
-  # n(&method(:m))               #=> true
-  # n(&method(:m).to_proc)       #=> true
-  # ```
-  # 
-  # `define_method` is treated the same as method definition. The defined
-  # method has no tricks.
-  # 
-  # ```ruby
-  # class C
-  #   define_method(:d) {}
-  # end
-  # C.new.d(1,2)       #=> ArgumentError
-  # C.new.method(:d).to_proc.lambda?   #=> true
-  # ```
-  # 
-  # `define_method` always defines a method without the tricks, even if a
-  # non-lambda [Proc](Proc.downloaded.ruby_doc) object is given. This is the
-  # only exception for which the tricks are not preserved.
-  # 
-  # ```ruby
-  # class C
-  #   define_method(:e, &proc {})
-  # end
-  # C.new.e(1,2)       #=> ArgumentError
-  # C.new.method(:e).to_proc.lambda?   #=> true
-  # ```
-  # 
-  # This exception ensures that methods never have tricks and makes it easy
-  # to have wrappers to define methods that behave as usual.
-  # 
-  # ```ruby
-  # class C
-  #   def self.def2(name, &body)
-  #     define_method(name, &body)
-  #   end
-  # 
-  #   def2(:f) {}
-  # end
-  # C.new.f(1,2)       #=> ArgumentError
-  # ```
-  # 
-  # The wrapper *def2* defines a method which has no tricks.
-  def lambda?: () -> bool
-
-  # Returns the parameter information of this proc.
-  # 
-  # ```ruby
-  # prc = lambda{|x, y=42, *other|}
-  # prc.parameters  #=> [[:req, :x], [:opt, :y], [:rest, :other]]
-  # ```
-  def parameters: () -> ::Array[[ Symbol, Symbol ]]
-
-  # Returns the Ruby source filename and line number containing this proc or
-  # `nil` if this proc was not defined in Ruby (i.e. native).
-  def source_location: () -> [ String, Integer ]
-
-  # Part of the protocol for converting objects to `Proc` objects. Instances
-  # of class `Proc` simply return themselves.
-  def to_proc: () -> self
-
-  # Returns the unique identifier for this proc, along with an indication of
-  # where the proc was defined.
-  # 
-  # 
-  # 
-  # Also aliased as: [inspect](Proc.downloaded.ruby_doc#method-i-inspect)
-  def to_s: () -> String
-
-  # Alias for: [to\_s](Proc.downloaded.ruby_doc#method-i-to_s)
-  def inspect: () -> String
-end

data/vendor/ruby-signature/stdlib/builtin/process.rbs

@@ -1,1227 +0,0 @@
-# The module contains several groups of functionality for handling OS processes:
-#
-# *   Low-level property introspection and management of the current process,
-#     like Process.argv0, Process.pid;
-# *   Low-level introspection of other processes, like Process.getpgid,
-#     Process.getpriority;
-# *   Management of the current process: Process.abort, Process.exit,
-#     Process.daemon, etc. (for convenience, most of those are also available as
-#     global functions and module functions of Kernel);
-# *   Creation and management of child processes: Process.fork, Process.spawn,
-#     and related methods;
-# *   Management of low-level system clock: Process.times and
-#     Process.clock_gettime, which could be important for proper benchmarking
-#     and other elapsed time measurement tasks.
-#
-#
-module Process
-  # Returns the name of the script being executed.  The value is not affected by
-  # assigning a new value to $0.
-  #
-  # This method first appeared in Ruby 2.1 to serve as a global variable free
-  # means to get the script name.
-  #
-  def self.argv0: () -> String
-
-  # Returns the time resolution returned by POSIX clock_getres() function.
-  #
-  # `clock_id` specifies a kind of clock. See the document of
-  # `Process.clock_gettime` for details.
-  #
-  # `clock_id` can be a symbol as `Process.clock_gettime`. However the result may
-  # not be accurate. For example,
-  # `Process.clock_getres(:GETTIMEOFDAY_BASED_CLOCK_REALTIME)` returns 1.0e-06
-  # which means 1 microsecond, but actual resolution can be more coarse.
-  #
-  # If the given `clock_id` is not supported, Errno::EINVAL is raised.
-  #
-  # `unit` specifies a type of the return value. `Process.clock_getres` accepts
-  # `unit` as `Process.clock_gettime`. The default value, `:float_second`, is also
-  # same as `Process.clock_gettime`.
-  #
-  # `Process.clock_getres` also accepts `:hertz` as `unit`. `:hertz` means a the
-  # reciprocal of `:float_second`.
-  #
-  # `:hertz` can be used to obtain the exact value of the clock ticks per second
-  # for times() function and CLOCKS_PER_SEC for clock() function.
-  #
-  # `Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)` returns
-  # the clock ticks per second.
-  #
-  # `Process.clock_getres(:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)` returns
-  # CLOCKS_PER_SEC.
-  #
-  #     p Process.clock_getres(Process::CLOCK_MONOTONIC)
-  #     #=> 1.0e-09
-  #
-  def self.clock_getres: (Symbol | Integer clock_id, ?Symbol unit) -> (Float | Integer)
-
-  # Returns a time returned by POSIX clock_gettime() function.
-  #
-  #     p Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  #     #=> 896053.968060096
-  #
-  # `clock_id` specifies a kind of clock. It is specified as a constant which
-  # begins with `Process::CLOCK_` such as Process::CLOCK_REALTIME and
-  # Process::CLOCK_MONOTONIC.
-  #
-  # The supported constants depends on OS and version. Ruby provides following
-  # types of `clock_id` if available.
-  #
-  # CLOCK_REALTIME
-  # :   SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1, macOS
-  #     10.12
-  # CLOCK_MONOTONIC
-  # :   SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4, macOS
-  #     10.12
-  # CLOCK_PROCESS_CPUTIME_ID
-  # :   SUSv3 to 4, Linux 2.5.63, FreeBSD 9.3, OpenBSD 5.4, macOS 10.12
-  # CLOCK_THREAD_CPUTIME_ID
-  # :   SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1, OpenBSD 5.4, macOS 10.12
-  # CLOCK_VIRTUAL
-  # :   FreeBSD 3.0, OpenBSD 2.1
-  # CLOCK_PROF
-  # :   FreeBSD 3.0, OpenBSD 2.1
-  # CLOCK_REALTIME_FAST
-  # :   FreeBSD 8.1
-  # CLOCK_REALTIME_PRECISE
-  # :   FreeBSD 8.1
-  # CLOCK_REALTIME_COARSE
-  # :   Linux 2.6.32
-  # CLOCK_REALTIME_ALARM
-  # :   Linux 3.0
-  # CLOCK_MONOTONIC_FAST
-  # :   FreeBSD 8.1
-  # CLOCK_MONOTONIC_PRECISE
-  # :   FreeBSD 8.1
-  # CLOCK_MONOTONIC_COARSE
-  # :   Linux 2.6.32
-  # CLOCK_MONOTONIC_RAW
-  # :   Linux 2.6.28, macOS 10.12
-  # CLOCK_MONOTONIC_RAW_APPROX
-  # :   macOS 10.12
-  # CLOCK_BOOTTIME
-  # :   Linux 2.6.39
-  # CLOCK_BOOTTIME_ALARM
-  # :   Linux 3.0
-  # CLOCK_UPTIME
-  # :   FreeBSD 7.0, OpenBSD 5.5
-  # CLOCK_UPTIME_FAST
-  # :   FreeBSD 8.1
-  # CLOCK_UPTIME_RAW
-  # :   macOS 10.12
-  # CLOCK_UPTIME_RAW_APPROX
-  # :   macOS 10.12
-  # CLOCK_UPTIME_PRECISE
-  # :   FreeBSD 8.1
-  # CLOCK_SECOND
-  # :   FreeBSD 8.1
-  # CLOCK_TAI
-  # :   Linux 3.10
-  #
-  #
-  # Note that SUS stands for Single Unix Specification. SUS contains POSIX and
-  # clock_gettime is defined in the POSIX part. SUS defines CLOCK_REALTIME
-  # mandatory but CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID and
-  # CLOCK_THREAD_CPUTIME_ID are optional.
-  #
-  # Also, several symbols are accepted as `clock_id`. There are emulations for
-  # clock_gettime().
-  #
-  # For example, Process::CLOCK_REALTIME is defined as
-  # `:GETTIMEOFDAY_BASED_CLOCK_REALTIME` when clock_gettime() is not available.
-  #
-  # Emulations for `CLOCK_REALTIME`:
-  # :GETTIMEOFDAY_BASED_CLOCK_REALTIME
-  # :   Use gettimeofday() defined by SUS. (SUSv4 obsoleted it, though.) The
-  #     resolution is 1 microsecond.
-  # :TIME_BASED_CLOCK_REALTIME
-  # :   Use time() defined by ISO C. The resolution is 1 second.
-  #
-  #
-  # Emulations for `CLOCK_MONOTONIC`:
-  # :MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC
-  # :   Use mach_absolute_time(), available on Darwin. The resolution is CPU
-  #     dependent.
-  # :TIMES_BASED_CLOCK_MONOTONIC
-  # :   Use the result value of times() defined by POSIX. POSIX defines it as
-  #     "times() shall return the elapsed real time, in clock ticks, since an
-  #     arbitrary point in the past (for example, system start-up time)". For
-  #     example, GNU/Linux returns a value based on jiffies and it is monotonic.
-  #     However, 4.4BSD uses gettimeofday() and it is not monotonic. (FreeBSD uses
-  #     clock_gettime(CLOCK_MONOTONIC) instead, though.) The resolution is the
-  #     clock tick. "getconf CLK_TCK" command shows the clock ticks per second.
-  #     (The clock ticks per second is defined by HZ macro in older systems.) If
-  #     it is 100 and clock_t is 32 bits integer type, the resolution is 10
-  #     millisecond and cannot represent over 497 days.
-  #
-  #
-  # Emulations for `CLOCK_PROCESS_CPUTIME_ID`:
-  # :GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID
-  # :   Use getrusage() defined by SUS. getrusage() is used with RUSAGE_SELF to
-  #     obtain the time only for the calling process (excluding the time for child
-  #     processes). The result is addition of user time (ru_utime) and system time
-  #     (ru_stime). The resolution is 1 microsecond.
-  # :TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID
-  # :   Use times() defined by POSIX. The result is addition of user time
-  #     (tms_utime) and system time (tms_stime). tms_cutime and tms_cstime are
-  #     ignored to exclude the time for child processes. The resolution is the
-  #     clock tick. "getconf CLK_TCK" command shows the clock ticks per second.
-  #     (The clock ticks per second is defined by HZ macro in older systems.) If
-  #     it is 100, the resolution is 10 millisecond.
-  # :CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID
-  # :   Use clock() defined by ISO C. The resolution is 1/CLOCKS_PER_SEC.
-  #     CLOCKS_PER_SEC is the C-level macro defined by time.h. SUS defines
-  #     CLOCKS_PER_SEC is 1000000. Non-Unix systems may define it a different
-  #     value, though. If CLOCKS_PER_SEC is 1000000 as SUS, the resolution is 1
-  #     microsecond. If CLOCKS_PER_SEC is 1000000 and clock_t is 32 bits integer
-  #     type, it cannot represent over 72 minutes.
-  #
-  #
-  # If the given `clock_id` is not supported, Errno::EINVAL is raised.
-  #
-  # `unit` specifies a type of the return value.
-  #
-  # :float_second
-  # :   number of seconds as a float (default)
-  # :float_millisecond
-  # :   number of milliseconds as a float
-  # :float_microsecond
-  # :   number of microseconds as a float
-  # :second
-  # :   number of seconds as an integer
-  # :millisecond
-  # :   number of milliseconds as an integer
-  # :microsecond
-  # :   number of microseconds as an integer
-  # :nanosecond
-  # :   number of nanoseconds as an integer
-  #
-  #
-  # The underlying function, clock_gettime(), returns a number of nanoseconds.
-  # Float object (IEEE 754 double) is not enough to represent the return value for
-  # CLOCK_REALTIME. If the exact nanoseconds value is required, use `:nanoseconds`
-  # as the `unit`.
-  #
-  # The origin (zero) of the returned value varies. For example, system start up
-  # time, process start up time, the Epoch, etc.
-  #
-  # The origin in CLOCK_REALTIME is defined as the Epoch (1970-01-01 00:00:00
-  # UTC). But some systems count leap seconds and others doesn't. So the result
-  # can be interpreted differently across systems. Time.now is recommended over
-  # CLOCK_REALTIME.
-  #
-  def self.clock_gettime: (Symbol | Integer clock_id, ?Symbol unit) -> (Float | Integer)
-
-  # Detach the process from controlling terminal and run in the background as
-  # system daemon.  Unless the argument nochdir is true (i.e. non false), it
-  # changes the current working directory to the root ("/"). Unless the argument
-  # noclose is true, daemon() will redirect standard input, standard output and
-  # standard error to /dev/null. Return zero on success, or raise one of Errno::*.
-  #
-  def self.daemon: (?untyped nochdir, ?untyped noclose) -> Integer
-
-  # Some operating systems retain the status of terminated child processes until
-  # the parent collects that status (normally using some variant of `wait()`). If
-  # the parent never collects this status, the child stays around as a *zombie*
-  # process. Process::detach prevents this by setting up a separate Ruby thread
-  # whose sole job is to reap the status of the process *pid* when it terminates.
-  # Use #detach only when you do not intend to explicitly wait for the child to
-  # terminate.
-  #
-  # The waiting thread returns the exit status of the detached process when it
-  # terminates, so you can use Thread#join to know the result.  If specified *pid*
-  # is not a valid child process ID, the thread returns `nil` immediately.
-  #
-  # The waiting thread has #pid method which returns the pid.
-  #
-  # In this first example, we don't reap the first child process, so it appears as
-  # a zombie in the process status display.
-  #
-  #     p1 = fork { sleep 0.1 }
-  #     p2 = fork { sleep 0.2 }
-  #     Process.waitpid(p2)
-  #     sleep 2
-  #     system("ps -ho pid,state -p #{p1}")
-  #
-  # *produces:*
-  #
-  #     27389 Z
-  #
-  # In the next example, Process::detach is used to reap the child automatically.
-  #
-  #     p1 = fork { sleep 0.1 }
-  #     p2 = fork { sleep 0.2 }
-  #     Process.detach(p1)
-  #     Process.waitpid(p2)
-  #     sleep 2
-  #     system("ps -ho pid,state -p #{p1}")
-  #
-  # *(produces no output)*
-  #
-  def self.detach: (Integer pid) -> Thread
-
-  # Returns the effective group ID for this process. Not available on all
-  # platforms.
-  #
-  #     Process.egid   #=> 500
-  #
-  def self.egid: () -> Integer
-
-  # Sets the effective group ID for this process. Not available on all platforms.
-  #
-  def self.egid=: (Integer arg0) -> Integer
-
-  # Returns the effective user ID for this process.
-  #
-  #     Process.euid   #=> 501
-  #
-  def self.euid: () -> Integer
-
-  # Sets the effective user ID for this process. Not available on all platforms.
-  #
-  def self.euid=: (Integer arg0) -> Integer
-
-  # Returns the process group ID for the given process id. Not available on all
-  # platforms.
-  #
-  #     Process.getpgid(Process.ppid())   #=> 25527
-  #
-  def self.getpgid: (Integer pid) -> Integer
-
-  # Returns the process group ID for this process. Not available on all platforms.
-  #
-  #     Process.getpgid(0)   #=> 25527
-  #     Process.getpgrp      #=> 25527
-  #
-  def self.getpgrp: () -> Integer
-
-  # Gets the scheduling priority for specified process, process group, or user.
-  # *kind* indicates the kind of entity to find: one of Process::PRIO_PGRP,
-  # Process::PRIO_USER, or Process::PRIO_PROCESS. *integer* is an id indicating
-  # the particular process, process group, or user (an id of 0 means *current*).
-  # Lower priorities are more favorable for scheduling. Not available on all
-  # platforms.
-  #
-  #     Process.getpriority(Process::PRIO_USER, 0)      #=> 19
-  #     Process.getpriority(Process::PRIO_PROCESS, 0)   #=> 19
-  #
-  def self.getpriority: (Integer kind, Integer arg0) -> Integer
-
-  # Gets the resource limit of the process. *cur_limit* means current (soft) limit
-  # and *max_limit* means maximum (hard) limit.
-  #
-  # *resource* indicates the kind of resource to limit. It is specified as a
-  # symbol such as `:CORE`, a string such as `"CORE"` or a constant such as
-  # Process::RLIMIT_CORE. See Process.setrlimit for details.
-  #
-  # *cur_limit* and *max_limit* may be Process::RLIM_INFINITY,
-  # Process::RLIM_SAVED_MAX or Process::RLIM_SAVED_CUR. See Process.setrlimit and
-  # the system getrlimit(2) manual for details.
-  #
-  def self.getrlimit: (Symbol | String | Integer resource) -> [ Integer, Integer ]
-
-  # Returns the session ID for the given process id. If not given, return current
-  # process sid. Not available on all platforms.
-  #
-  #     Process.getsid()                #=> 27422
-  #     Process.getsid(0)               #=> 27422
-  #     Process.getsid(Process.pid())   #=> 27422
-  #
-  def self.getsid: (?Integer pid) -> Integer
-
-  # Returns the (real) group ID for this process.
-  #
-  #     Process.gid   #=> 500
-  #
-  def self.gid: () -> Integer
-
-  # Sets the group ID for this process.
-  #
-  def self.gid=: (Integer arg0) -> Integer
-
-  # Get an Array of the group IDs in the supplemental group access list for this
-  # process.
-  #
-  #     Process.groups   #=> [27, 6, 10, 11]
-  #
-  # Note that this method is just a wrapper of getgroups(2). This means that the
-  # following characteristics of the result completely depend on your system:
-  #
-  # *   the result is sorted
-  # *   the result includes effective GIDs
-  # *   the result does not include duplicated GIDs
-  #
-  #
-  # You can make sure to get a sorted unique GID list of the current process by
-  # this expression:
-  #
-  #     Process.groups.uniq.sort
-  #
-  def self.groups: () -> ::Array[Integer]
-
-  # Set the supplemental group access list to the given Array of group IDs.
-  #
-  #     Process.groups   #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
-  #     Process.groups = [27, 6, 10, 11]   #=> [27, 6, 10, 11]
-  #     Process.groups   #=> [27, 6, 10, 11]
-  #
-  def self.groups=: (::Array[Integer] arg0) -> ::Array[Integer]
-
-  # Initializes the supplemental group access list by reading the system group
-  # database and using all groups of which the given user is a member. The group
-  # with the specified *gid* is also added to the list. Returns the resulting
-  # Array of the gids of all the groups in the supplementary group access list.
-  # Not available on all platforms.
-  #
-  #     Process.groups   #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
-  #     Process.initgroups( "mgranger", 30 )   #=> [30, 6, 10, 11]
-  #     Process.groups   #=> [30, 6, 10, 11]
-  #
-  def self.initgroups: (String username, Integer gid) -> ::Array[Integer]
-
-  # Sends the given signal to the specified process id(s) if *pid* is positive. If
-  # *pid* is zero, *signal* is sent to all processes whose group ID is equal to
-  # the group ID of the process. If *pid* is negative, results are dependent on
-  # the operating system. *signal* may be an integer signal number or a POSIX
-  # signal name (either with or without a `SIG` prefix). If *signal* is negative
-  # (or starts with a minus sign), kills process groups instead of processes. Not
-  # all signals are available on all platforms. The keys and values of Signal.list
-  # are known signal names and numbers, respectively.
-  #
-  #     pid = fork do
-  #        Signal.trap("HUP") { puts "Ouch!"; exit }
-  #        # ... do some work ...
-  #     end
-  #     # ...
-  #     Process.kill("HUP", pid)
-  #     Process.wait
-  #
-  # *produces:*
-  #
-  #     Ouch!
-  #
-  # If *signal* is an integer but wrong for signal, Errno::EINVAL or RangeError
-  # will be raised.  Otherwise unless *signal* is a String or a Symbol, and a
-  # known signal name, ArgumentError will be raised.
-  #
-  # Also, Errno::ESRCH or RangeError for invalid *pid*, Errno::EPERM when failed
-  # because of no privilege, will be raised.  In these cases, signals may have
-  # been sent to preceding processes.
-  #
-  def self.kill: (Integer | Symbol | String signal, *Integer pids) -> Integer
-
-  # Returns the maximum number of gids allowed in the supplemental group access
-  # list.
-  #
-  #     Process.maxgroups   #=> 32
-  #
-  def self.maxgroups: () -> Integer
-
-  # Sets the maximum number of gids allowed in the supplemental group access list.
-  #
-  def self.maxgroups=: (Integer arg0) -> Integer
-
-  # Returns the process id of this process. Not available on all platforms.
-  #
-  #     Process.pid   #=> 27415
-  #
-  def self.pid: () -> Integer
-
-  # Returns the process id of the parent of this process. Returns untrustworthy
-  # value on Win32/64. Not available on all platforms.
-  #
-  #     puts "I am #{Process.pid}"
-  #     Process.fork { puts "Dad is #{Process.ppid}" }
-  #
-  # *produces:*
-  #
-  #     I am 27417
-  #     Dad is 27417
-  #
-  def self.ppid: () -> Integer
-
-  # Sets the process group ID of *pid* (0 indicates this process) to *integer*.
-  # Not available on all platforms.
-  #
-  def self.setpgid: (Integer pid, Integer arg0) -> Integer
-
-  # See Process.getpriority.
-  #
-  #     Process.setpriority(Process::PRIO_USER, 0, 19)      #=> 0
-  #     Process.setpriority(Process::PRIO_PROCESS, 0, 19)   #=> 0
-  #     Process.getpriority(Process::PRIO_USER, 0)          #=> 19
-  #     Process.getpriority(Process::PRIO_PROCESS, 0)       #=> 19
-  #
-  def self.setpriority: (Integer kind, Integer arg0, Integer priority) -> Integer
-
-  # Sets the process title that appears on the ps(1) command.  Not necessarily
-  # effective on all platforms.  No exception will be raised regardless of the
-  # result, nor will NotImplementedError be raised even if the platform does not
-  # support the feature.
-  #
-  # Calling this method does not affect the value of $0.
-  #
-  #     Process.setproctitle('myapp: worker #%d' % worker_id)
-  #
-  # This method first appeared in Ruby 2.1 to serve as a global variable free
-  # means to change the process title.
-  #
-  def self.setproctitle: (String arg0) -> String
-
-  # Sets the resource limit of the process. *cur_limit* means current (soft) limit
-  # and *max_limit* means maximum (hard) limit.
-  #
-  # If *max_limit* is not given, *cur_limit* is used.
-  #
-  # *resource* indicates the kind of resource to limit. It should be a symbol such
-  # as `:CORE`, a string such as `"CORE"` or a constant such as
-  # Process::RLIMIT_CORE. The available resources are OS dependent. Ruby may
-  # support following resources.
-  #
-  # AS
-  # :   total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but
-  #     4.4BSD-Lite)
-  # CORE
-  # :   core size (bytes) (SUSv3)
-  # CPU
-  # :   CPU time (seconds) (SUSv3)
-  # DATA
-  # :   data segment (bytes) (SUSv3)
-  # FSIZE
-  # :   file size (bytes) (SUSv3)
-  # MEMLOCK
-  # :   total size for mlock(2) (bytes) (4.4BSD, GNU/Linux)
-  # MSGQUEUE
-  # :   allocation for POSIX message queues (bytes) (GNU/Linux)
-  # NICE
-  # :   ceiling on process's nice(2) value (number) (GNU/Linux)
-  # NOFILE
-  # :   file descriptors (number) (SUSv3)
-  # NPROC
-  # :   number of processes for the user (number) (4.4BSD, GNU/Linux)
-  # RSS
-  # :   resident memory size (bytes) (4.2BSD, GNU/Linux)
-  # RTPRIO
-  # :   ceiling on the process's real-time priority (number) (GNU/Linux)
-  # RTTIME
-  # :   CPU time for real-time process (us) (GNU/Linux)
-  # SBSIZE
-  # :   all socket buffers (bytes) (NetBSD, FreeBSD)
-  # SIGPENDING
-  # :   number of queued signals allowed (signals) (GNU/Linux)
-  # STACK
-  # :   stack size (bytes) (SUSv3)
-  #
-  #
-  # *cur_limit* and *max_limit* may be `:INFINITY`, `"INFINITY"` or
-  # Process::RLIM_INFINITY, which means that the resource is not limited. They may
-  # be Process::RLIM_SAVED_MAX, Process::RLIM_SAVED_CUR and corresponding symbols
-  # and strings too. See system setrlimit(2) manual for details.
-  #
-  # The following example raises the soft limit of core size to the hard limit to
-  # try to make core dump possible.
-  #
-  #     Process.setrlimit(:CORE, Process.getrlimit(:CORE)[1])
-  #
-  def self.setrlimit: (Symbol | String | Integer resource, Integer cur_limit, ?Integer max_limit) -> nil
-
-  # Establishes this process as a new session and process group leader, with no
-  # controlling tty. Returns the session id. Not available on all platforms.
-  #
-  #     Process.setsid   #=> 27422
-  #
-  def self.setsid: () -> Integer
-
-  # Returns a `Tms` structure (see Process::Tms) that contains user and system CPU
-  # times for this process, and also for children processes.
-  #
-  #     t = Process.times
-  #     [ t.utime, t.stime, t.cutime, t.cstime ]   #=> [0.0, 0.02, 0.00, 0.00]
-  #
-  def self.times: () -> Process::Tms
-
-  # Returns the (real) user ID of this process.
-  #
-  #     Process.uid   #=> 501
-  #
-  def self.uid: () -> Integer
-
-  # Sets the (user) user ID for this process. Not available on all platforms.
-  #
-  def self.uid=: (Integer user) -> Integer
-
-  # Waits for a child process to exit, returns its process id, and sets `$?` to a
-  # Process::Status object containing information on that process. Which child it
-  # waits on depends on the value of *pid*:
-  #
-  # > 0
-  # :   Waits for the child whose process ID equals *pid*.
-  #
-  # 0
-  # :   Waits for any child whose process group ID equals that of the calling
-  #     process.
-  #
-  # -1
-  # :   Waits for any child process (the default if no *pid* is given).
-  #
-  # < -1
-  # :   Waits for any child whose process group ID equals the absolute value of
-  #     *pid*.
-  #
-  #
-  # The *flags* argument may be a logical or of the flag values Process::WNOHANG
-  # (do not block if no child available) or Process::WUNTRACED (return stopped
-  # children that haven't been reported). Not all flags are available on all
-  # platforms, but a flag value of zero will work on all platforms.
-  #
-  # Calling this method raises a SystemCallError if there are no child processes.
-  # Not available on all platforms.
-  #
-  #     include Process
-  #     fork { exit 99 }                 #=> 27429
-  #     wait                             #=> 27429
-  #     $?.exitstatus                    #=> 99
-  #
-  #     pid = fork { sleep 3 }           #=> 27440
-  #     Time.now                         #=> 2008-03-08 19:56:16 +0900
-  #     waitpid(pid, Process::WNOHANG)   #=> nil
-  #     Time.now                         #=> 2008-03-08 19:56:16 +0900
-  #     waitpid(pid, 0)                  #=> 27440
-  #     Time.now                         #=> 2008-03-08 19:56:19 +0900
-  #
-  def self.wait: (?Integer pid, ?Integer flags) -> Integer
-
-  # Waits for a child process to exit (see Process::waitpid for exact semantics)
-  # and returns an array containing the process id and the exit status (a
-  # Process::Status object) of that child. Raises a SystemCallError if there are
-  # no child processes.
-  #
-  #     Process.fork { exit 99 }   #=> 27437
-  #     pid, status = Process.wait2
-  #     pid                        #=> 27437
-  #     status.exitstatus          #=> 99
-  #
-  def self.wait2: (?Integer pid, ?Integer flags) -> [ Integer, Process::Status ]
-
-  # Waits for all children, returning an array of *pid*/*status* pairs (where
-  # *status* is a Process::Status object).
-  #
-  #     fork { sleep 0.2; exit 2 }   #=> 27432
-  #     fork { sleep 0.1; exit 1 }   #=> 27433
-  #     fork {            exit 0 }   #=> 27434
-  #     p Process.waitall
-  #
-  # *produces*:
-  #
-  #     [[30982, #<Process::Status: pid 30982 exit 0>],
-  #      [30979, #<Process::Status: pid 30979 exit 1>],
-  #      [30976, #<Process::Status: pid 30976 exit 2>]]
-  #
-  def self.waitall: () -> ::Array[[ Integer, Process::Status ]]
-
-  # Waits for a child process to exit, returns its process id, and sets `$?` to a
-  # Process::Status object containing information on that process. Which child it
-  # waits on depends on the value of *pid*:
-  #
-  # > 0
-  # :   Waits for the child whose process ID equals *pid*.
-  #
-  # 0
-  # :   Waits for any child whose process group ID equals that of the calling
-  #     process.
-  #
-  # -1
-  # :   Waits for any child process (the default if no *pid* is given).
-  #
-  # < -1
-  # :   Waits for any child whose process group ID equals the absolute value of
-  #     *pid*.
-  #
-  #
-  # The *flags* argument may be a logical or of the flag values Process::WNOHANG
-  # (do not block if no child available) or Process::WUNTRACED (return stopped
-  # children that haven't been reported). Not all flags are available on all
-  # platforms, but a flag value of zero will work on all platforms.
-  #
-  # Calling this method raises a SystemCallError if there are no child processes.
-  # Not available on all platforms.
-  #
-  #     include Process
-  #     fork { exit 99 }                 #=> 27429
-  #     wait                             #=> 27429
-  #     $?.exitstatus                    #=> 99
-  #
-  #     pid = fork { sleep 3 }           #=> 27440
-  #     Time.now                         #=> 2008-03-08 19:56:16 +0900
-  #     waitpid(pid, Process::WNOHANG)   #=> nil
-  #     Time.now                         #=> 2008-03-08 19:56:16 +0900
-  #     waitpid(pid, 0)                  #=> 27440
-  #     Time.now                         #=> 2008-03-08 19:56:19 +0900
-  #
-  def self.waitpid: (?Integer pid, ?Integer flags) -> Integer
-
-  # Waits for a child process to exit (see Process::waitpid for exact semantics)
-  # and returns an array containing the process id and the exit status (a
-  # Process::Status object) of that child. Raises a SystemCallError if there are
-  # no child processes.
-  #
-  #     Process.fork { exit 99 }   #=> 27437
-  #     pid, status = Process.wait2
-  #     pid                        #=> 27437
-  #     status.exitstatus          #=> 99
-  #
-  def self.waitpid2: (?Integer pid, ?Integer flags) -> [ Integer, Process::Status ]
-end
-
-# see Process.clock_gettime
-#
-#
-Process::CLOCK_BOOTTIME: Integer
-
-# see Process.clock_gettime
-#
-#
-Process::CLOCK_BOOTTIME_ALARM: Integer
-
-# see Process.clock_gettime
-#
-#
-Process::CLOCK_MONOTONIC: Integer
-
-# see Process.clock_gettime
-#
-#
-Process::CLOCK_MONOTONIC_COARSE: Integer
-
-# see Process.clock_gettime
-#
-#
-Process::CLOCK_MONOTONIC_RAW: Integer
-
-# see Process.clock_gettime
-#
-#
-Process::CLOCK_PROCESS_CPUTIME_ID: Integer
-
-# see Process.clock_gettime
-#
-#
-Process::CLOCK_REALTIME: Integer
-
-# see Process.clock_gettime
-#
-#
-Process::CLOCK_REALTIME_ALARM: Integer
-
-# see Process.clock_gettime
-#
-#
-Process::CLOCK_REALTIME_COARSE: Integer
-
-# see Process.clock_gettime
-#
-#
-Process::CLOCK_THREAD_CPUTIME_ID: Integer
-
-# see Process.setpriority
-#
-#
-Process::PRIO_PGRP: Integer
-
-# see Process.setpriority
-#
-#
-Process::PRIO_PROCESS: Integer
-
-# see Process.setpriority
-#
-#
-Process::PRIO_USER: Integer
-
-# Maximum size of the process's virtual memory (address space) in bytes.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_AS: Integer
-
-# Maximum size of the core file.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_CORE: Integer
-
-# CPU time limit in seconds.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_CPU: Integer
-
-# Maximum size of the process's data segment.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_DATA: Integer
-
-# Maximum size of files that the process may create.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_FSIZE: Integer
-
-# Maximum number of bytes of memory that may be locked into RAM.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_MEMLOCK: Integer
-
-# Specifies the limit on the number of bytes that can be allocated for POSIX
-# message queues for the real user ID of the calling process.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_MSGQUEUE: Integer
-
-# Specifies a ceiling to which the process's nice value can be raised.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_NICE: Integer
-
-# Specifies a value one greater than the maximum file descriptor number that can
-# be opened by this process.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_NOFILE: Integer
-
-# The maximum number of processes that can be created for the real user ID of
-# the calling process.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_NPROC: Integer
-
-# Specifies the limit (in pages) of the process's resident set.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_RSS: Integer
-
-# Specifies a ceiling on the real-time priority that may be set for this
-# process.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_RTPRIO: Integer
-
-# Specifies limit on CPU time this process scheduled under a real-time
-# scheduling policy can consume.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_RTTIME: Integer
-
-# Specifies a limit on the number of signals that may be queued for the real
-# user ID of the calling process.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_SIGPENDING: Integer
-
-# Maximum size of the stack, in bytes.
-#
-# see the system getrlimit(2) manual for details.
-#
-Process::RLIMIT_STACK: Integer
-
-# see Process.setrlimit
-#
-#
-Process::RLIM_INFINITY: Integer
-
-# see Process.setrlimit
-#
-#
-Process::RLIM_SAVED_CUR: Integer
-
-# see Process.setrlimit
-#
-#
-Process::RLIM_SAVED_MAX: Integer
-
-# see Process.wait
-#
-#
-Process::WNOHANG: Integer
-
-# see Process.wait
-#
-#
-Process::WUNTRACED: Integer
-
-# The Process::GID module contains a collection of module functions which can be
-# used to portably get, set, and switch the current process's real, effective,
-# and saved group IDs.
-#
-module Process::GID
-  # Change the current process's real and effective group ID to that specified by
-  # *group*. Returns the new group ID. Not available on all platforms.
-  #
-  #     [Process.gid, Process.egid]          #=> [0, 0]
-  #     Process::GID.change_privilege(33)    #=> 33
-  #     [Process.gid, Process.egid]          #=> [33, 33]
-  #
-  def self.change_privilege: (Integer group) -> Integer
-
-  # Returns the effective group ID for this process. Not available on all
-  # platforms.
-  #
-  #     Process.egid   #=> 500
-  #
-  def self.eid: () -> Integer
-
-  # Get the group ID by the *name*. If the group is not found, `ArgumentError`
-  # will be raised.
-  #
-  #     Process::GID.from_name("wheel") #=> 0
-  #     Process::GID.from_name("nosuchgroup") #=> can't find group for nosuchgroup (ArgumentError)
-  #
-  def self.from_name: (String name) -> Integer
-
-  # Set the effective group ID, and if possible, the saved group ID of the process
-  # to the given *group*. Returns the new effective group ID. Not available on all
-  # platforms.
-  #
-  #     [Process.gid, Process.egid]          #=> [0, 0]
-  #     Process::GID.grant_privilege(31)     #=> 33
-  #     [Process.gid, Process.egid]          #=> [0, 33]
-  #
-  def self.grant_privilege: (Integer group) -> Integer
-
-  # Exchange real and effective group IDs and return the new effective group ID.
-  # Not available on all platforms.
-  #
-  #     [Process.gid, Process.egid]   #=> [0, 33]
-  #     Process::GID.re_exchange      #=> 0
-  #     [Process.gid, Process.egid]   #=> [33, 0]
-  #
-  def self.re_exchange: () -> Integer
-
-  # Returns `true` if the real and effective group IDs of a process may be
-  # exchanged on the current platform.
-  #
-  def self.re_exchangeable?: () -> bool
-
-  # Returns the (real) group ID for this process.
-  #
-  #     Process.gid   #=> 500
-  #
-  def self.rid: () -> Integer
-
-  # Returns `true` if the current platform has saved group ID functionality.
-  #
-  def self.sid_available?: () -> bool
-
-  # Switch the effective and real group IDs of the current process. If a *block*
-  # is given, the group IDs will be switched back after the block is executed.
-  # Returns the new effective group ID if called without a block, and the return
-  # value of the block if one is given.
-  #
-  def self.switch: () -> Integer
-                 | [T] () { () -> T } -> T
-
-  def self.eid=: (Integer group) -> Integer
-end
-
-# Process::Status encapsulates the information on the status of a running or
-# terminated system process. The built-in variable `$?` is either `nil` or a
-# Process::Status object.
-#
-#     fork { exit 99 }   #=> 26557
-#     Process.wait       #=> 26557
-#     $?.class           #=> Process::Status
-#     $?.to_i            #=> 25344
-#     $? >> 8            #=> 99
-#     $?.stopped?        #=> false
-#     $?.exited?         #=> true
-#     $?.exitstatus      #=> 99
-#
-# Posix systems record information on processes using a 16-bit integer.  The
-# lower bits record the process status (stopped, exited, signaled) and the upper
-# bits possibly contain additional information (for example the program's return
-# code in the case of exited processes). Pre Ruby 1.8, these bits were exposed
-# directly to the Ruby program. Ruby now encapsulates these in a Process::Status
-# object. To maximize compatibility, however, these objects retain a
-# bit-oriented interface. In the descriptions that follow, when we talk about
-# the integer value of *stat*, we're referring to this 16 bit value.
-#
-class Process::Status < Object
-  # Logical AND of the bits in *stat* with *num*.
-  #
-  #     fork { exit 0x37 }
-  #     Process.wait
-  #     sprintf('%04x', $?.to_i)       #=> "3700"
-  #     sprintf('%04x', $? & 0x1e00)   #=> "1600"
-  #
-  def &: (Integer num) -> Integer
-
-  # Returns `true` if the integer value of *stat* equals *other*.
-  #
-  def ==: (untyped other) -> bool
-
-  # Shift the bits in *stat* right *num* places.
-  #
-  #     fork { exit 99 }   #=> 26563
-  #     Process.wait       #=> 26563
-  #     $?.to_i            #=> 25344
-  #     $? >> 8            #=> 99
-  #
-  def >>: (Integer num) -> Integer
-
-  # Returns `true` if *stat* generated a coredump when it terminated. Not
-  # available on all platforms.
-  #
-  def coredump?: () -> bool
-
-  # Returns `true` if *stat* exited normally (for example using an `exit()` call
-  # or finishing the program).
-  #
-  def exited?: () -> bool
-
-  # Returns the least significant eight bits of the return code of *stat*. Only
-  # available if #exited? is `true`.
-  #
-  #     fork { }           #=> 26572
-  #     Process.wait       #=> 26572
-  #     $?.exited?         #=> true
-  #     $?.exitstatus      #=> 0
-  #
-  #     fork { exit 99 }   #=> 26573
-  #     Process.wait       #=> 26573
-  #     $?.exited?         #=> true
-  #     $?.exitstatus      #=> 99
-  #
-  def exitstatus: () -> Integer?
-
-  # Override the inspection method.
-  #
-  #     system("false")
-  #     p $?.inspect #=> "#<Process::Status: pid 12861 exit 1>"
-  #
-  def inspect: () -> String
-
-  # Returns the process ID that this status object represents.
-  #
-  #     fork { exit }   #=> 26569
-  #     Process.wait    #=> 26569
-  #     $?.pid          #=> 26569
-  #
-  def pid: () -> Integer
-
-  # Returns `true` if *stat* terminated because of an uncaught signal.
-  #
-  def signaled?: () -> bool
-
-  # Returns `true` if this process is stopped. This is only returned if the
-  # corresponding #wait call had the Process::WUNTRACED flag set.
-  #
-  def stopped?: () -> bool
-
-  # Returns the number of the signal that caused *stat* to stop (or `nil` if self
-  # is not stopped).
-  #
-  def stopsig: () -> Integer?
-
-  # Returns `true` if *stat* is successful, `false` if not. Returns `nil` if
-  # #exited? is not `true`.
-  #
-  def success?: () -> bool
-
-  # Returns the number of the signal that caused *stat* to terminate (or `nil` if
-  # self was not terminated by an uncaught signal).
-  #
-  def termsig: () -> Integer?
-
-  # Returns the bits in *stat* as a Integer. Poking around in these bits is
-  # platform dependent.
-  #
-  #     fork { exit 0xab }         #=> 26566
-  #     Process.wait               #=> 26566
-  #     sprintf('%04x', $?.to_i)   #=> "ab00"
-  #
-  def to_i: () -> Integer
-
-  # Show pid and exit status as a string.
-  #
-  #     system("false")
-  #     p $?.to_s         #=> "pid 12766 exit 1"
-  #
-  def to_s: () -> String
-end
-
-# The Process::Sys module contains UID and GID functions which provide direct
-# bindings to the system calls of the same names instead of the more-portable
-# versions of the same functionality found in the Process, Process::UID, and
-# Process::GID modules.
-#
-module Process::Sys
-  # Returns the effective user ID for this process.
-  #
-  #     Process.euid   #=> 501
-  #
-  def self.geteuid: () -> Integer
-
-  # Returns the (real) group ID for this process.
-  #
-  #     Process.gid   #=> 500
-  #
-  def self.getgid: () -> Integer
-
-  # Returns the (real) user ID of this process.
-  #
-  #     Process.uid   #=> 501
-  #
-  def self.getuid: () -> Integer
-
-  # Returns `true` if the process was created as a result of an execve(2) system
-  # call which had either of the setuid or setgid bits set (and extra privileges
-  # were given as a result) or if it has changed any of its real, effective or
-  # saved user or group IDs since it began execution.
-  #
-  def self.issetugid: () -> bool
-
-  # Set the effective group ID of the calling process to *group*.  Not available
-  # on all platforms.
-  #
-  def self.setegid: (Integer group) -> nil
-
-  # Set the effective user ID of the calling process to *user*.  Not available on
-  # all platforms.
-  #
-  def self.seteuid: (Integer user) -> nil
-
-  # Set the group ID of the current process to *group*. Not available on all
-  # platforms.
-  #
-  def self.setgid: (Integer group) -> nil
-
-  # Sets the (group) real and/or effective group IDs of the current process to
-  # *rid* and *eid*, respectively. A value of `-1` for either means to leave that
-  # ID unchanged. Not available on all platforms.
-  #
-  def self.setregid: (Integer rid, Integer eid) -> nil
-
-  # Sets the (group) real, effective, and saved user IDs of the current process to
-  # *rid*, *eid*, and *sid* respectively. A value of `-1` for any value means to
-  # leave that ID unchanged. Not available on all platforms.
-  #
-  def self.setresgid: (Integer rid, Integer eid, Integer sid) -> nil
-
-  # Sets the (user) real, effective, and saved user IDs of the current process to
-  # *rid*, *eid*, and *sid* respectively. A value of `-1` for any value means to
-  # leave that ID unchanged. Not available on all platforms.
-  #
-  def self.setresuid: (Integer rid, Integer eid, Integer sid) -> nil
-
-  # Sets the (user) real and/or effective user IDs of the current process to *rid*
-  # and *eid*, respectively. A value of `-1` for either means to leave that ID
-  # unchanged. Not available on all platforms.
-  #
-  def self.setreuid: (Integer rid, Integer eid) -> nil
-
-  # Set the real group ID of the calling process to *group*. Not available on all
-  # platforms.
-  #
-  def self.setrgid: (Integer group) -> nil
-
-  # Set the real user ID of the calling process to *user*. Not available on all
-  # platforms.
-  #
-  def self.setruid: (Integer user) -> nil
-
-  # Set the user ID of the current process to *user*. Not available on all
-  # platforms.
-  #
-  def self.setuid: (Integer user) -> nil
-end
-
-# The Process::UID module contains a collection of module functions which can be
-# used to portably get, set, and switch the current process's real, effective,
-# and saved user IDs.
-#
-module Process::UID
-  # Change the current process's real and effective user ID to that specified by
-  # *user*. Returns the new user ID. Not available on all platforms.
-  #
-  #     [Process.uid, Process.euid]          #=> [0, 0]
-  #     Process::UID.change_privilege(31)    #=> 31
-  #     [Process.uid, Process.euid]          #=> [31, 31]
-  #
-  def self.change_privilege: (Integer user) -> Integer
-
-  # Returns the effective user ID for this process.
-  #
-  #     Process.euid   #=> 501
-  #
-  def self.eid: () -> Integer
-
-  # Get the user ID by the *name*. If the user is not found, `ArgumentError` will
-  # be raised.
-  #
-  #     Process::UID.from_name("root") #=> 0
-  #     Process::UID.from_name("nosuchuser") #=> can't find user for nosuchuser (ArgumentError)
-  #
-  def self.from_name: (String name) -> Integer
-
-  # Set the effective user ID, and if possible, the saved user ID of the process
-  # to the given *user*. Returns the new effective user ID. Not available on all
-  # platforms.
-  #
-  #     [Process.uid, Process.euid]          #=> [0, 0]
-  #     Process::UID.grant_privilege(31)     #=> 31
-  #     [Process.uid, Process.euid]          #=> [0, 31]
-  #
-  def self.grant_privilege: (Integer user) -> Integer
-
-  # Exchange real and effective user IDs and return the new effective user ID. Not
-  # available on all platforms.
-  #
-  #     [Process.uid, Process.euid]   #=> [0, 31]
-  #     Process::UID.re_exchange      #=> 0
-  #     [Process.uid, Process.euid]   #=> [31, 0]
-  #
-  def self.re_exchange: () -> Integer
-
-  # Returns `true` if the real and effective user IDs of a process may be
-  # exchanged on the current platform.
-  #
-  def self.re_exchangeable?: () -> bool
-
-  # Returns the (real) user ID of this process.
-  #
-  #     Process.uid   #=> 501
-  #
-  def self.rid: () -> Integer
-
-  # Returns `true` if the current platform has saved user ID functionality.
-  #
-  def self.sid_available?: () -> bool
-
-  # Switch the effective and real user IDs of the current process. If a *block* is
-  # given, the user IDs will be switched back after the block is executed. Returns
-  # the new effective user ID if called without a block, and the return value of
-  # the block if one is given.
-  #
-  def self.switch: () -> Integer
-                 | [T] () { () -> T } -> T
-
-  def self.eid=: (Integer user) -> Integer
-end
-
-class Process::Tms < Struct[Float]
-end
-
-class Process::Waiter < Thread
-  def pid: () -> Integer
-end