rbs 1.1.0 → 1.3.0

data/stdlib/rubygems/0/requirement.rbs

@@ -1,3 +1,85 @@
-class Gem::Requirement
-  # TODO: Add sinatures...
+module Gem
+  # A Requirement is a set of one or more version restrictions. It supports a few
+  # (`=, !=, >, <, >=, <=, ~>`) different restriction operators.
+  #
+  # See Gem::Version for a description on how versions and requirements work
+  # together in RubyGems.
+  #
+  class Requirement
+    type operator = "=" | "!=" | ">" | "<" | ">=" | "<=" | "~>"
+
+    # Raised when a bad requirement is encountered
+    #
+    class BadRequirementError < ArgumentError
+    end
+
+    # The default requirement matches any version
+    #
+    DefaultPrereleaseRequirement: [ operator, Gem::Version ]
+
+    # The default requirement matches any non-prerelease version
+    #
+    DefaultRequirement: [ operator, Gem::Version ]
+
+    # A regular expression that matches a requirement
+    #
+    PATTERN: Regexp
+
+    # Factory method to create a Gem::Requirement object.  Input may be a Version, a
+    # String, or nil.  Intended to simplify client code.
+    #
+    # If the input is "weird", the default version requirement is returned.
+    #
+    def self.create: (*(String | Gem::Version | Gem::Requirement | nil) inputs) -> instance
+
+    def self.default: () -> instance
+
+    def self.default_prerelease: () -> instance
+
+    # Parse `obj`, returning an `[op, version]` pair. `obj` can be a String or a
+    # Gem::Version.
+    #
+    # If `obj` is a String, it can be either a full requirement specification, like
+    # `">= 1.2"`, or a simple version number, like `"1.2"`.
+    #
+    #     parse("> 1.0")                 # => [">", Gem::Version.new("1.0")]
+    #     parse("1.0")                   # => ["=", Gem::Version.new("1.0")]
+    #     parse(Gem::Version.new("1.0")) # => ["=,  Gem::Version.new("1.0")]
+    #
+    def self.parse: (String | Gem::Version obj) -> [ operator, Gem::Version ]
+
+    # Constructs a requirement from `requirements`. Requirements can be Strings,
+    # Gem::Versions, or Arrays of those. `nil` and duplicate requirements are
+    # ignored. An empty set of `requirements` is the same as `">= 0"`.
+    #
+    def initialize: (*(String | Gem::Version) requirements) -> void
+
+    # Concatenates the `new` requirements onto this requirement.
+    #
+    def concat: (Array[String | Gem::Version] new) -> void
+
+    # true if the requirement is for only an exact version
+    #
+    def exact?: () -> bool
+
+    # true if this gem has no requirements.
+    #
+    def none?: () -> bool
+
+    # A requirement is a prerelease if any of the versions inside of it are
+    # prereleases
+    #
+    def prerelease?: () -> bool
+
+    # True if `version` satisfies this Requirement.
+    #
+    def satisfied_by?: (Gem::Version version) -> bool
+
+    alias === satisfied_by?
+    alias =~ satisfied_by?
+
+    # True if the requirement will not always match the latest version.
+    #
+    def specific?: () -> bool
+  end
 end

data/stdlib/rubygems/0/rubygems.rbs

@@ -338,7 +338,7 @@ module Gem
   #
   def self.find_unresolved_default_spec: (String path) -> Specification?
 
-  def self.finish_resolve: (?RequestSet request_set) -> Array[Specification]
+  def self.finish_resolve: (?RequestSet request_set) -> void
 
   # GemDependencyAPI object, which is set when .use_gemdeps is called. This
   # contains all the information from the Gemfile.
@@ -417,7 +417,7 @@ module Gem
   #
   def self.marshal_version: () -> String
 
-  def self.needs: () { (RequestSet) -> untyped } -> Array[Specification]
+  def self.needs: () { (RequestSet) -> void } -> void
 
   # Default options for gem commands for Ruby packagers.
   #

data/stdlib/rubygems/0/version.rbs

@@ -170,7 +170,8 @@ module Gem
     #     ver2 = Version.create(ver1)       # -> (ver1)
     #     ver3 = Version.create(nil)        # -> nil
     #
-    def self.create: (_ToS | Version | nil input) -> instance?
+    def self.create: (_ToS | Version input) -> instance
+                   | (nil input) -> nil
 
     # Constructs a Version from the `version` string.  A version string is a series
     # of digits or ASCII letters separated by dots.

data/stdlib/shellwords/0/shellwords.rbs

@@ -0,0 +1,252 @@
+# ## Manipulates strings like the UNIX Bourne shell
+#
+# This module manipulates strings according to the word parsing rules of the
+# UNIX Bourne shell.
+#
+# The shellwords() function was originally a port of shellwords.pl, but modified
+# to conform to the Shell & Utilities volume of the IEEE Std 1003.1-2008, 2016
+# Edition [1].
+#
+# ### Usage
+#
+# You can use Shellwords to parse a string into a Bourne shell friendly Array.
+#
+#     require 'shellwords'
+#
+#     argv = Shellwords.split('three blind "mice"')
+#     argv #=> ["three", "blind", "mice"]
+#
+# Once you've required Shellwords, you can use the #split alias
+# String#shellsplit.
+#
+#     argv = "see how they run".shellsplit
+#     argv #=> ["see", "how", "they", "run"]
+#
+# They treat quotes as special characters, so an unmatched quote will cause an
+# ArgumentError.
+#
+#     argv = "they all ran after the farmer's wife".shellsplit
+#          #=> ArgumentError: Unmatched quote: ...
+#
+# Shellwords also provides methods that do the opposite. Shellwords.escape, or
+# its alias, String#shellescape, escapes shell metacharacters in a string for
+# use in a command line.
+#
+#     filename = "special's.txt"
+#
+#     system("cat -- #{filename.shellescape}")
+#     # runs "cat -- special\\'s.txt"
+#
+# Note the '--'.  Without it, cat(1) will treat the following argument as a
+# command line option if it starts with '-'.  It is guaranteed that
+# Shellwords.escape converts a string to a form that a Bourne shell will parse
+# back to the original string, but it is the programmer's responsibility to make
+# sure that passing an arbitrary argument to a command does no harm.
+#
+# Shellwords also comes with a core extension for Array, Array#shelljoin.
+#
+#     dir = "Funny GIFs"
+#     argv = %W[ls -lta -- #{dir}]
+#     system(argv.shelljoin + " | less")
+#     # runs "ls -lta -- Funny\\ GIFs | less"
+#
+# You can use this method to build a complete command line out of an array of
+# arguments.
+#
+# ### Authors
+# *   Wakou Aoyama
+# *   Akinori MUSHA <knu@iDaemons.org>
+#
+#
+# ### Contact
+# *   Akinori MUSHA <knu@iDaemons.org> (current maintainer)
+#
+#
+# ### Resources
+#
+# 1: [IEEE Std 1003.1-2008, 2016 Edition, the Shell & Utilities
+# volume](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/contents.htm
+# l)
+module Shellwords
+  # Escapes a string so that it can be safely used in a Bourne shell command line.
+  #  `str` can be a non-string object that responds to `to_s`.
+  #
+  # Note that a resulted string should be used unquoted and is not intended for
+  # use in double quotes nor in single quotes.
+  #
+  #     argv = Shellwords.escape("It's better to give than to receive")
+  #     argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  # String#shellescape is a shorthand for this function.
+  #
+  #     argv = "It's better to give than to receive".shellescape
+  #     argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  #     # Search files in lib for method definitions
+  #     pattern = "^[ \t]*def "
+  #     open("| grep -Ern -e #{pattern.shellescape} lib") { |grep|
+  #       grep.each_line { |line|
+  #         file, lineno, matched_line = line.split(':', 3)
+  #         # ...
+  #       }
+  #     }
+  #
+  # It is the caller's responsibility to encode the string in the right encoding
+  # for the shell environment where this string is used.
+  #
+  # Multibyte characters are treated as multibyte characters, not as bytes.
+  #
+  # Returns an empty quoted String if `str` has a length of zero.
+  #
+  def self.shellescape: (String str) -> String
+
+  # Builds a command line string from an argument list, `array`.
+  #
+  # All elements are joined into a single string with fields separated by a space,
+  # where each element is escaped for the Bourne shell and stringified using
+  # `to_s`.
+  #
+  #     ary = ["There's", "a", "time", "and", "place", "for", "everything"]
+  #     argv = Shellwords.join(ary)
+  #     argv #=> "There\\'s a time and place for everything"
+  #
+  # Array#shelljoin is a shortcut for this function.
+  #
+  #     ary = ["Don't", "rock", "the", "boat"]
+  #     argv = ary.shelljoin
+  #     argv #=> "Don\\'t rock the boat"
+  #
+  # You can also mix non-string objects in the elements as allowed in Array#join.
+  #
+  #     output = `#{['ps', '-p', $$].shelljoin}`
+  #
+  def self.shelljoin: (Array[String] array) -> String
+
+  # Splits a string into an array of tokens in the same way the UNIX Bourne shell
+  # does.
+  #
+  #     argv = Shellwords.split('here are "two words"')
+  #     argv #=> ["here", "are", "two words"]
+  #
+  # Note, however, that this is not a command line parser.  Shell metacharacters
+  # except for the single and double quotes and backslash are not treated as such.
+  #
+  #     argv = Shellwords.split('ruby my_prog.rb | less')
+  #     argv #=> ["ruby", "my_prog.rb", "|", "less"]
+  #
+  # String#shellsplit is a shortcut for this function.
+  #
+  #     argv = 'here are "two words"'.shellsplit
+  #     argv #=> ["here", "are", "two words"]
+  #
+  def self.shellsplit: (String line) -> Array[String]
+
+  alias self.escape self.shellescape
+
+  alias self.join self.shelljoin
+
+  alias self.shellwords self.shellsplit
+
+  alias self.split self.shellsplit
+
+  private
+
+  # Escapes a string so that it can be safely used in a Bourne shell command line.
+  #  `str` can be a non-string object that responds to `to_s`.
+  #
+  # Note that a resulted string should be used unquoted and is not intended for
+  # use in double quotes nor in single quotes.
+  #
+  #     argv = Shellwords.escape("It's better to give than to receive")
+  #     argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  # String#shellescape is a shorthand for this function.
+  #
+  #     argv = "It's better to give than to receive".shellescape
+  #     argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  #     # Search files in lib for method definitions
+  #     pattern = "^[ \t]*def "
+  #     open("| grep -Ern -e #{pattern.shellescape} lib") { |grep|
+  #       grep.each_line { |line|
+  #         file, lineno, matched_line = line.split(':', 3)
+  #         # ...
+  #       }
+  #     }
+  #
+  # It is the caller's responsibility to encode the string in the right encoding
+  # for the shell environment where this string is used.
+  #
+  # Multibyte characters are treated as multibyte characters, not as bytes.
+  #
+  # Returns an empty quoted String if `str` has a length of zero.
+  #
+  def shellescape: (String str) -> String
+
+  # Builds a command line string from an argument list, `array`.
+  #
+  # All elements are joined into a single string with fields separated by a space,
+  # where each element is escaped for the Bourne shell and stringified using
+  # `to_s`.
+  #
+  #     ary = ["There's", "a", "time", "and", "place", "for", "everything"]
+  #     argv = Shellwords.join(ary)
+  #     argv #=> "There\\'s a time and place for everything"
+  #
+  # Array#shelljoin is a shortcut for this function.
+  #
+  #     ary = ["Don't", "rock", "the", "boat"]
+  #     argv = ary.shelljoin
+  #     argv #=> "Don\\'t rock the boat"
+  #
+  # You can also mix non-string objects in the elements as allowed in Array#join.
+  #
+  #     output = `#{['ps', '-p', $$].shelljoin}`
+  #
+  def shelljoin: (Array[String] array) -> String
+
+  # Splits a string into an array of tokens in the same way the UNIX Bourne shell
+  # does.
+  #
+  #     argv = Shellwords.split('here are "two words"')
+  #     argv #=> ["here", "are", "two words"]
+  #
+  # Note, however, that this is not a command line parser.  Shell metacharacters
+  # except for the single and double quotes and backslash are not treated as such.
+  #
+  #     argv = Shellwords.split('ruby my_prog.rb | less')
+  #     argv #=> ["ruby", "my_prog.rb", "|", "less"]
+  #
+  # String#shellsplit is a shortcut for this function.
+  #
+  #     argv = 'here are "two words"'.shellsplit
+  #     argv #=> ["here", "are", "two words"]
+  #
+  def shellsplit: (String line) -> Array[String]
+
+  alias shellwords shellsplit
+end
+
+class Array[unchecked out Elem]
+  # Builds a command line string from an argument list `array` joining all
+  # elements escaped for the Bourne shell and separated by a space.
+  #
+  # See Shellwords.shelljoin for details.
+  #
+  def shelljoin: () -> String
+end
+
+class String
+  # Escapes `str` so that it can be safely used in a Bourne shell command line.
+  #
+  # See Shellwords.shellescape for details.
+  #
+  def shellescape: () -> String
+
+  # Splits `str` into an array of tokens in the same way the UNIX Bourne shell
+  # does.
+  #
+  # See Shellwords.shellsplit for details.
+  #
+  def shellsplit: () -> Array[String]
+end

data/stdlib/socket/0/addrinfo.rbs

@@ -0,0 +1,469 @@
+class Addrinfo
+  # iterates over the list of Addrinfo objects obtained by Addrinfo.getaddrinfo.
+  #
+  #     Addrinfo.foreach(nil, 80) {|x| p x }
+  #     #=> #<Addrinfo: 127.0.0.1:80 TCP (:80)>
+  #     #   #<Addrinfo: 127.0.0.1:80 UDP (:80)>
+  #     #   #<Addrinfo: [::1]:80 TCP (:80)>
+  #     #   #<Addrinfo: [::1]:80 UDP (:80)>
+  #
+  def self.foreach: (String? nodename, String | Integer service, ?Integer? family, ?Symbol socktype, ?(Symbol | Integer) protocol, ?Integer flags, ?timeout: Numeric) { (Addrinfo) -> void } -> void
+                  |(String? nodename, String | Integer service, ?Integer? family, ?Symbol socktype, ?(Symbol | Integer) protocol, ?Integer flags, ?timeout: Numeric) -> Enumerable[Addrinfo]
+
+                  # returns a list of addrinfo objects as an array.
+  #
+  # This method converts nodename (hostname) and service (port) to addrinfo. Since
+  # the conversion is not unique, the result is a list of addrinfo objects.
+  #
+  # nodename or service can be nil if no conversion intended.
+  #
+  # family, socktype and protocol are hint for preferred protocol. If the result
+  # will be used for a socket with SOCK_STREAM, SOCK_STREAM should be specified as
+  # socktype. If so, Addrinfo.getaddrinfo returns addrinfo list appropriate for
+  # SOCK_STREAM. If they are omitted or nil is given, the result is not
+  # restricted.
+  #
+  # Similarly, PF_INET6 as family restricts for IPv6.
+  #
+  # flags should be bitwise OR of Socket::AI_??? constants such as follows. Note
+  # that the exact list of the constants depends on OS.
+  #
+  #     AI_PASSIVE      Get address to use with bind()
+  #     AI_CANONNAME    Fill in the canonical name
+  #     AI_NUMERICHOST  Prevent host name resolution
+  #     AI_NUMERICSERV  Prevent service name resolution
+  #     AI_V4MAPPED     Accept IPv4-mapped IPv6 addresses
+  #     AI_ALL          Allow all addresses
+  #     AI_ADDRCONFIG   Accept only if any address is assigned
+  #
+  # Note that socktype should be specified whenever application knows the usage of
+  # the address. Some platform causes an error when socktype is omitted and
+  # servname is specified as an integer because some port numbers, 512 for
+  # example, are ambiguous without socktype.
+  #
+  #     Addrinfo.getaddrinfo("www.kame.net", 80, nil, :STREAM)
+  #     #=> [#<Addrinfo: 203.178.141.194:80 TCP (www.kame.net)>,
+  #     #    #<Addrinfo: [2001:200:dff:fff1:216:3eff:feb1:44d7]:80 TCP (www.kame.net)>]
+  #
+  def self.getaddrinfo: (String nodename, ?(String | Integer) service, ?Symbol? family, ?(Symbol | Integer) protocol) -> Array[Addrinfo]
+
+  # returns an addrinfo object for IP address.
+  #
+  # The port, socktype, protocol of the result is filled by zero. So, it is not
+  # appropriate to create a socket.
+  #
+  #     Addrinfo.ip("localhost") #=> #<Addrinfo: 127.0.0.1 (localhost)>
+  #
+  def self.ip: (String host) -> Addrinfo
+
+  # returns an addrinfo object for TCP address.
+  #
+  #     Addrinfo.tcp("localhost", "smtp") #=> #<Addrinfo: 127.0.0.1:25 TCP (localhost:smtp)>
+  #
+  def self.tcp: (String host, String | Integer service) -> Addrinfo
+
+  # returns an addrinfo object for UDP address.
+  #
+  #     Addrinfo.udp("localhost", "daytime") #=> #<Addrinfo: 127.0.0.1:13 UDP (localhost:daytime)>
+  #
+  def self.udp: (String host, String | Integer service) -> Addrinfo
+
+  # returns an addrinfo object for UNIX socket address.
+  #
+  # *socktype* specifies the socket type. If it is omitted, :STREAM is used.
+  #
+  #     Addrinfo.unix("/tmp/sock")         #=> #<Addrinfo: /tmp/sock SOCK_STREAM>
+  #     Addrinfo.unix("/tmp/sock", :DGRAM) #=> #<Addrinfo: /tmp/sock SOCK_DGRAM>
+  #
+  def self.unix: (String path, ?Symbol socktype) -> Addrinfo
+
+  public
+
+  # returns the address family as an integer.
+  #
+  #     Addrinfo.tcp("localhost", 80).afamily == Socket::AF_INET #=> true
+  #
+  def afamily: () -> Integer
+
+  # creates a socket bound to self.
+  #
+  # If a block is given, it is called with the socket and the value of the block
+  # is returned. The socket is returned otherwise.
+  #
+  #     Addrinfo.udp("0.0.0.0", 9981).bind {|s|
+  #       s.local_address.connect {|s| s.send "hello", 0 }
+  #       p s.recv(10) #=> "hello"
+  #     }
+  #
+  def bind: () -> Socket
+          |  () { (Socket) -> void } -> void
+
+  # returns the canonical name as a string.
+  #
+  # nil is returned if no canonical name.
+  #
+  # The canonical name is set by Addrinfo.getaddrinfo when AI_CANONNAME is
+  # specified.
+  #
+  #     list = Addrinfo.getaddrinfo("www.ruby-lang.org", 80, :INET, :STREAM, nil, Socket::AI_CANONNAME)
+  #     p list[0] #=> #<Addrinfo: 221.186.184.68:80 TCP carbon.ruby-lang.org (www.ruby-lang.org)>
+  #     p list[0].canonname #=> "carbon.ruby-lang.org"
+  #
+  def canonname: () -> String
+
+  # creates a socket connected to the address of self.
+  #
+  # The optional argument *opts* is options represented by a hash. *opts* may have
+  # following options:
+  #
+  # :timeout
+  # :   specify the timeout in seconds.
+  #
+  #
+  # If a block is given, it is called with the socket and the value of the block
+  # is returned. The socket is returned otherwise.
+  #
+  #     Addrinfo.tcp("www.ruby-lang.org", 80).connect {|s|
+  #       s.print "GET / HTTP/1.0\r\nHost: www.ruby-lang.org\r\n\r\n"
+  #       puts s.read
+  #     }
+  #
+  def connect: (?timeout: Numeric) { (Socket) -> void } -> void
+             | (?timeout: Numeric) -> Socket
+
+  # creates a socket connected to the address of self.
+  #
+  # If one or more arguments given as *local_addr_args*, it is used as the local
+  # address of the socket. *local_addr_args* is given for family_addrinfo to
+  # obtain actual address.
+  #
+  # If *local_addr_args* is not given, the local address of the socket is not
+  # bound.
+  #
+  # The optional last argument *opts* is options represented by a hash. *opts* may
+  # have following options:
+  #
+  # :timeout
+  # :   specify the timeout in seconds.
+  #
+  #
+  # If a block is given, it is called with the socket and the value of the block
+  # is returned. The socket is returned otherwise.
+  #
+  #     Addrinfo.tcp("www.ruby-lang.org", 80).connect_from("0.0.0.0", 4649) {|s|
+  #       s.print "GET / HTTP/1.0\r\nHost: www.ruby-lang.org\r\n\r\n"
+  #       puts s.read
+  #     }
+  #
+  #     # Addrinfo object can be taken for the argument.
+  #     Addrinfo.tcp("www.ruby-lang.org", 80).connect_from(Addrinfo.tcp("0.0.0.0", 4649)) {|s|
+  #       s.print "GET / HTTP/1.0\r\nHost: www.ruby-lang.org\r\n\r\n"
+  #       puts s.read
+  #     }
+  #
+  def connect_from: (String host, Integer port, ?timeout: Numeric) { (Socket) -> void } -> void
+                  | (String host, Integer port, ?timeout: Numeric)  -> Socket
+                  | (Addrinfo sockaddr, ?timeout: Numeric) { (Socket) -> void } -> void
+                  | (Addrinfo sockaddr, ?timeout: Numeric) -> Socket
+
+  # creates a socket connected to *remote_addr_args* and bound to self.
+  #
+  # The optional last argument *opts* is options represented by a hash. *opts* may
+  # have following options:
+  #
+  # :timeout
+  # :   specify the timeout in seconds.
+  #
+  #
+  # If a block is given, it is called with the socket and the value of the block
+  # is returned. The socket is returned otherwise.
+  #
+  #     Addrinfo.tcp("0.0.0.0", 4649).connect_to("www.ruby-lang.org", 80) {|s|
+  #       s.print "GET / HTTP/1.0\r\nHost: www.ruby-lang.org\r\n\r\n"
+  #       puts s.read
+  #     }
+  #
+  def connect_to: (String host, Integer port, ?timeout: Numeric) { (Socket) -> void } -> void
+                | (String host, Integer port, ?timeout: Numeric)  -> Socket
+                | (Addrinfo sockaddr, ?timeout: Numeric) { (Socket) -> void } -> void
+                | (Addrinfo sockaddr, ?timeout: Numeric) -> Socket
+
+  # creates an Addrinfo object from the arguments.
+  #
+  # The arguments are interpreted as similar to self.
+  #
+  #     Addrinfo.tcp("0.0.0.0", 4649).family_addrinfo("www.ruby-lang.org", 80)
+  #     #=> #<Addrinfo: 221.186.184.68:80 TCP (www.ruby-lang.org:80)>
+  #
+  #     Addrinfo.unix("/tmp/sock").family_addrinfo("/tmp/sock2")
+  #     #=> #<Addrinfo: /tmp/sock2 SOCK_STREAM>
+  #
+  def family_addrinfo: (String host, Integer port) -> Addrinfo
+                     | (String path) -> Addrinfo
+
+  # returns nodename and service as a pair of strings. This converts struct
+  # sockaddr in addrinfo to textual representation.
+  #
+  # flags should be bitwise OR of Socket::NI_??? constants.
+  #
+  #     Addrinfo.tcp("127.0.0.1", 80).getnameinfo #=> ["localhost", "www"]
+  #
+  #     Addrinfo.tcp("127.0.0.1", 80).getnameinfo(Socket::NI_NUMERICSERV)
+  #     #=> ["localhost", "80"]
+  #
+  def getnameinfo: (?Integer flags) -> [String, Integer]
+
+  # returns a string which shows addrinfo in human-readable form.
+  #
+  #     Addrinfo.tcp("localhost", 80).inspect #=> "#<Addrinfo: 127.0.0.1:80 TCP (localhost)>"
+  #     Addrinfo.unix("/tmp/sock").inspect    #=> "#<Addrinfo: /tmp/sock SOCK_STREAM>"
+  #
+  def inspect: () -> String
+
+  # returns a string which shows the sockaddr in *addrinfo* with human-readable
+  # form.
+  #
+  #     Addrinfo.tcp("localhost", 80).inspect_sockaddr     #=> "127.0.0.1:80"
+  #     Addrinfo.tcp("ip6-localhost", 80).inspect_sockaddr #=> "[::1]:80"
+  #     Addrinfo.unix("/tmp/sock").inspect_sockaddr        #=> "/tmp/sock"
+  #
+  def inspect_sockaddr: () -> String
+
+  # returns true if addrinfo is internet (IPv4/IPv6) address. returns false
+  # otherwise.
+  #
+  #     Addrinfo.tcp("127.0.0.1", 80).ip? #=> true
+  #     Addrinfo.tcp("::1", 80).ip?       #=> true
+  #     Addrinfo.unix("/tmp/sock").ip?    #=> false
+  #
+  def ip?: () -> bool
+
+  # Returns the IP address as a string.
+  #
+  #     Addrinfo.tcp("127.0.0.1", 80).ip_address    #=> "127.0.0.1"
+  #     Addrinfo.tcp("::1", 80).ip_address          #=> "::1"
+  #
+  def ip_address: () -> String
+
+  # Returns the port number as an integer.
+  #
+  #     Addrinfo.tcp("127.0.0.1", 80).ip_port    #=> 80
+  #     Addrinfo.tcp("::1", 80).ip_port          #=> 80
+  #
+  def ip_port: () -> Integer
+
+  # Returns the IP address and port number as 2-element array.
+  #
+  #     Addrinfo.tcp("127.0.0.1", 80).ip_unpack    #=> ["127.0.0.1", 80]
+  #     Addrinfo.tcp("::1", 80).ip_unpack          #=> ["::1", 80]
+  #
+  def ip_unpack: () -> [String, Integer]
+
+  # returns true if addrinfo is IPv4 address. returns false otherwise.
+  #
+  #     Addrinfo.tcp("127.0.0.1", 80).ipv4? #=> true
+  #     Addrinfo.tcp("::1", 80).ipv4?       #=> false
+  #     Addrinfo.unix("/tmp/sock").ipv4?    #=> false
+  #
+  def ipv4?: () -> bool
+
+  # Returns true for IPv4 loopback address (127.0.0.0/8). It returns false
+  # otherwise.
+  #
+  def ipv4_loopback?: () -> bool
+
+  # Returns true for IPv4 multicast address (224.0.0.0/4). It returns false
+  # otherwise.
+  #
+  def ipv4_multicast?: () -> bool
+
+  # Returns true for IPv4 private address (10.0.0.0/8, 172.16.0.0/12,
+  # 192.168.0.0/16). It returns false otherwise.
+  #
+  def ipv4_private?: () -> bool
+
+  # returns true if addrinfo is IPv6 address. returns false otherwise.
+  #
+  #     Addrinfo.tcp("127.0.0.1", 80).ipv6? #=> false
+  #     Addrinfo.tcp("::1", 80).ipv6?       #=> true
+  #     Addrinfo.unix("/tmp/sock").ipv6?    #=> false
+  #
+  def ipv6?: () -> bool
+
+  # Returns true for IPv6 link local address (ff80::/10). It returns false
+  # otherwise.
+  #
+  def ipv6_linklocal?: () -> bool
+
+  # Returns true for IPv6 loopback address (::1). It returns false otherwise.
+  #
+  def ipv6_loopback?: () -> bool
+
+  # Returns true for IPv6 multicast global scope address. It returns false
+  # otherwise.
+  #
+  def ipv6_mc_global?: () -> bool
+
+  # Returns true for IPv6 multicast link-local scope address. It returns false
+  # otherwise.
+  #
+  def ipv6_mc_linklocal?: () -> bool
+
+  # Returns true for IPv6 multicast node-local scope address. It returns false
+  # otherwise.
+  #
+  def ipv6_mc_nodelocal?: () -> bool
+
+  # Returns true for IPv6 multicast organization-local scope address. It returns
+  # false otherwise.
+  #
+  def ipv6_mc_orglocal?: () -> bool
+
+  # Returns true for IPv6 multicast site-local scope address. It returns false
+  # otherwise.
+  #
+  def ipv6_mc_sitelocal?: () -> bool
+
+  # Returns true for IPv6 multicast address (ff00::/8). It returns false
+  # otherwise.
+  #
+  def ipv6_multicast?: () -> bool
+
+  # Returns true for IPv6 site local address (ffc0::/10). It returns false
+  # otherwise.
+  #
+  def ipv6_sitelocal?: () -> bool
+
+  # Returns IPv4 address of IPv4 mapped/compatible IPv6 address. It returns nil if
+  # `self` is not IPv4 mapped/compatible IPv6 address.
+  #
+  #     Addrinfo.ip("::192.0.2.3").ipv6_to_ipv4      #=> #<Addrinfo: 192.0.2.3>
+  #     Addrinfo.ip("::ffff:192.0.2.3").ipv6_to_ipv4 #=> #<Addrinfo: 192.0.2.3>
+  #     Addrinfo.ip("::1").ipv6_to_ipv4              #=> nil
+  #     Addrinfo.ip("192.0.2.3").ipv6_to_ipv4        #=> nil
+  #     Addrinfo.unix("/tmp/sock").ipv6_to_ipv4      #=> nil
+  #
+  def ipv6_to_ipv4: () -> Addrinfo?
+
+  # Returns true for IPv6 unique local address (fc00::/7, RFC4193). It returns
+  # false otherwise.
+  #
+  def ipv6_unique_local?: () -> bool
+
+  # Returns true for IPv6 unspecified address (::). It returns false otherwise.
+  #
+  def ipv6_unspecified?: () -> bool
+
+  # Returns true for IPv4-compatible IPv6 address (::/80). It returns false
+  # otherwise.
+  #
+  def ipv6_v4compat?: () -> bool
+
+  # Returns true for IPv4-mapped IPv6 address (::ffff:0:0/80). It returns false
+  # otherwise.
+  #
+  def ipv6_v4mapped?: () -> bool
+
+  # creates a listening socket bound to self.
+  #
+  def listen: (Integer backlog) -> void
+
+  def marshal_dump: () -> String
+
+  def marshal_load: (String) -> instance
+
+  # returns the protocol family as an integer.
+  #
+  #     Addrinfo.tcp("localhost", 80).pfamily == Socket::PF_INET #=> true
+  #
+  def pfamily: () -> Integer
+
+  # returns the socket type as an integer.
+  #
+  #     Addrinfo.tcp("localhost", 80).protocol == Socket::IPPROTO_TCP #=> true
+  #
+  def protocol: () -> Integer
+
+  # returns the socket type as an integer.
+  #
+  #     Addrinfo.tcp("localhost", 80).socktype == Socket::SOCK_STREAM #=> true
+  #
+  def socktype: () -> Integer
+
+  # returns the socket address as packed struct sockaddr string.
+  #
+  #     Addrinfo.tcp("localhost", 80).to_sockaddr
+  #     #=> "\x02\x00\x00P\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
+  #
+  def to_s: () -> String
+
+  # returns the socket address as packed struct sockaddr string.
+  #
+  #     Addrinfo.tcp("localhost", 80).to_sockaddr
+  #     #=> "\x02\x00\x00P\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
+  #
+  def to_sockaddr: () -> String
+
+  # returns true if addrinfo is UNIX address. returns false otherwise.
+  #
+  #     Addrinfo.tcp("127.0.0.1", 80).unix? #=> false
+  #     Addrinfo.tcp("::1", 80).unix?       #=> false
+  #     Addrinfo.unix("/tmp/sock").unix?    #=> true
+  #
+  def unix?: () -> bool
+
+  # Returns the socket path as a string.
+  #
+  #     Addrinfo.unix("/tmp/sock").unix_path       #=> "/tmp/sock"
+  #
+  def unix_path: () -> String
+
+  private
+
+  # returns a new instance of Addrinfo. The instance contains sockaddr, family,
+  # socktype, protocol. sockaddr means struct sockaddr which can be used for
+  # connect(2), etc. family, socktype and protocol are integers which is used for
+  # arguments of socket(2).
+  #
+  # sockaddr is specified as an array or a string. The array should be compatible
+  # to the value of IPSocket#addr or UNIXSocket#addr. The string should be struct
+  # sockaddr as generated by Socket.sockaddr_in or Socket.unpack_sockaddr_un.
+  #
+  # sockaddr examples:
+  #
+  #     "AF_INET", 46102, "localhost.localdomain", "127.0.0.1"
+  # :
+  #
+  #     "AF_INET6", 42304, "ip6-localhost", "::1"
+  # :
+  #
+  #     "AF_UNIX", "/tmp/sock"
+  # :
+  # *   Socket.sockaddr_in("smtp", "2001:DB8::1")
+  # *   Socket.sockaddr_in(80, "172.18.22.42")
+  # *   Socket.sockaddr_in(80, "www.ruby-lang.org")
+  # *   Socket.sockaddr_un("/tmp/sock")
+  #
+  #
+  # In an AF_INET/AF_INET6 sockaddr array, the 4th element, numeric IP address, is
+  # used to construct socket address in the Addrinfo instance. If the 3rd element,
+  # textual host name, is non-nil, it is also recorded but used only for
+  # Addrinfo#inspect.
+  #
+  # family is specified as an integer to specify the protocol family such as
+  # Socket::PF_INET. It can be a symbol or a string which is the constant name
+  # with or without PF_ prefix such as :INET, :INET6, :UNIX, "PF_INET", etc. If
+  # omitted, PF_UNSPEC is assumed.
+  #
+  # socktype is specified as an integer to specify the socket type such as
+  # Socket::SOCK_STREAM. It can be a symbol or a string which is the constant name
+  # with or without SOCK_ prefix such as :STREAM, :DGRAM, :RAW, "SOCK_STREAM",
+  # etc. If omitted, 0 is assumed.
+  #
+  # protocol is specified as an integer to specify the protocol such as
+  # Socket::IPPROTO_TCP. It must be an integer, unlike family and socktype. If
+  # omitted, 0 is assumed. Note that 0 is reasonable value for most protocols,
+  # except raw socket.
+  #
+  def initialize: (String sockaddr, ?Symbol family, ?(Symbol | Integer)? socktype, ?Integer? protocol) -> untyped
+end