cybrid_api_organization_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/request.rbs

@@ -0,0 +1,99 @@
+module HTTPX
+  class Request
+    extend Forwardable
+    include Loggable
+    include Callbacks
+
+    METHODS: Array[Symbol]
+    USER_AGENT: String
+    ALLOWED_URI_SCHEMES: Array[String]
+
+    attr_reader verb: verb
+    attr_reader uri: http_uri
+    attr_reader headers: Headers
+    attr_reader body: Body
+    attr_reader state: Symbol
+    attr_reader options: Options
+    attr_reader response: response?
+    attr_reader http2_stream_options: { ?dependency: Integer, ?exclusive: bool, ?weight: Integer }
+    attr_reader drain_error: StandardError?
+    attr_reader active_timeouts: Array[Timers::Timer]
+
+    attr_writer connection: Connection?
+    attr_writer on_response_arrived: (^() -> void)?
+    attr_accessor peer_address: (String | IPAddr)?
+
+    attr_writer persistent: bool
+
+    @ping: bool
+    @query_params: Hash[interned, untyped]?
+    @trailers: Headers?
+    @informational_status: Integer?
+    @query: String?
+    @drainer: Enumerator[String, void]?
+    @started: bool
+    @complete: bool
+
+    def initialize: (Symbol | String verb, generic_uri uri, Options options, ?request_params params) -> untyped
+
+    def complete!: (?response response) -> bool
+
+    def started?: () -> bool
+
+    def ping?: () -> bool
+
+    def ping!: () -> void
+
+    def empty?: () -> bool
+
+    def close: () -> void
+
+    def interests: () -> (:r | :w)
+
+    def can_buffer? : () -> bool
+
+    def merge_headers: (_Each[[String, headers_value]]) -> void
+
+    def scheme: () -> String
+
+    def response=: (response) -> void
+
+    def path: () -> String
+
+    def authority: () -> String
+
+    def origin: () -> String
+
+    def query: () -> String
+
+    def drain_body: () -> String?
+
+    def inspect: () -> String
+
+    def transition: (Symbol) -> void
+
+    def expects?: () -> boolish
+
+    def trailers: () -> Headers
+
+    def trailers?: () -> boolish
+
+    def persistent?: () -> bool
+
+    def read_timeout: () -> interval?
+
+    def write_timeout: () -> interval?
+
+    def request_timeout: () -> interval?
+
+    def set_timeout_callback: (Symbol event) { (*untyped) -> void } -> void
+
+    def handle_error: (StandardError error) -> void
+
+    def emit_response: (response response) -> void
+
+    private
+
+    def reset_timers: (bool reset_total_request_timers) -> void
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/resolver/cache/base.rbs

@@ -0,0 +1,28 @@
+module HTTPX
+  module Resolver
+    class Cache::Base
+      include _Cache
+
+      MAX_CACHE_SIZE: Integer
+
+      CACHE_MUTEX: Thread::Mutex
+      HOSTS: Resolv::Hosts
+
+      self.@cache: instance?
+
+      def self.cache: (Symbol label) -> instance
+
+      private
+
+      def ip_resolve: (String hostname) -> Array[Entry]?
+
+      def hosts_resolve: (String hostname) -> Array[Entry]?
+
+      def _get: (String hostname, Hash[String, Array[dns_result]] lookups, Array[String] hostnames, Numeric ttl) -> Array[Entry]?
+
+      def _set: (String hostname, ip_family family, Array[dns_result] entries, Hash[String, Array[dns_result]] lookups, Array[String] hostnames) -> void
+
+      def _evict: (String hostname, String ip, Hash[String, Array[dns_result]] lookups, Array[String] hostnames) -> void
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/resolver/cache/file.rbs

@@ -0,0 +1,13 @@
+module HTTPX::Resolver
+  module Cache
+    class File < Base
+      DEFAULT_PATH: String
+
+      @store: PStore
+
+      private
+
+      def initialize: (?path path) -> void
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/resolver/cache/memory.rbs

@@ -0,0 +1,13 @@
+module HTTPX::Resolver
+  module Cache
+    class Memory < Base
+      @lookup_mutex: Thread::Mutex
+      @hostnames: Array[String]
+      @lookups: Hash[String, Array[dns_result]]
+
+      private
+
+      def synchronize: [U] () { (Hash[String, Array[dns_result]] lookups, Array[String] hostnames) -> U } -> U
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/resolver/cache.rbs

@@ -0,0 +1,16 @@
+module HTTPX
+  module Resolver
+    module Cache
+    end
+
+    interface _Cache
+      def resolve: (String hostname) -> Array[Entry]?
+
+      def get: (String hostname) -> Array[Entry]?
+
+      def set: (String hostname, ip_family family, Array[dns_result] addresses) -> void
+
+      def evict: (String hostname, _ToS ip) -> void
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/resolver/entry.rbs

@@ -0,0 +1,13 @@
+module HTTPX
+  class Resolver::Entry
+    attr_reader address: IPAddr | String
+
+    @expires_in: interval
+
+    def initialize: (IPAddr | _ToS address, ?Numeric expires_in, ?rescue_on_convert: boolish) -> void
+
+    def expired?: () -> bool
+
+    def self.convert: (IPAddr | _ToS address) -> Resolver::Entry
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/resolver/https.rbs

@@ -0,0 +1,71 @@
+module HTTPX
+  module Resolver
+    class HTTPS < Resolver
+      extend Forwardable
+
+      NAMESERVER: String
+
+      DEFAULTS: Hash[Symbol, untyped]
+      FAMILY_TYPES: Hash[singleton(Resolv::DNS::Resource), String]
+
+      attr_reader family: ip_family
+
+      @options: Options
+      @_timeouts: Array[interval]
+      @timeouts: Hash[String, Array[interval]]
+      @queries: Hash[String, Connection]
+      @requests: Hash[Request, String]
+      @connections: Array[Connection]
+      @uri: http_uri
+      @uri_addresses: Array[String]?
+      @name: String?
+      @resolver: Resolv::DNS
+      @resolver_connection: Connection
+
+      attr_writer pool: Pool
+
+      def <<: (Connection) -> void
+
+      # delegated to resolver connection
+      def connecting?: () -> bool
+
+      def to_io: () ->  IO
+
+      def call: () -> void
+
+      def close: () -> void
+
+      # def closed?: () -> bool
+
+      def deactivate: () -> void
+
+      def terminate: () -> void
+
+      def inflight?: () -> bool
+
+      def handle_socket_timeout: (interval interval) -> void
+
+      private
+
+      def initialize: (ip_family family, options options) -> void
+
+      def resolver_connection: () -> Connection
+
+      def send_request: (String hostname, Connection connection) -> void
+
+      def on_response: (Request, response) -> void
+
+      def parse: (Request request, Response response) -> void
+
+      def parse_addresses: (Array[dns_result] answers, Request request) -> void
+
+      def build_request: (String hostname) -> Request
+
+      def decode_response_body: (Response) -> dns_decoding_response
+
+      def reset_hostname: (String hostname, ?reset_candidates: bool) -> Connection?
+
+      def close_or_resolve: (?bool should_deactivate) -> void
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/resolver/multi.rbs

@@ -0,0 +1,31 @@
+module HTTPX
+  module Resolver
+    class Multi
+      attr_reader resolvers: Array[HTTPX::Resolver::Resolver]
+
+      attr_reader options: Options
+
+      @current_selector: Selector?
+      @current_session: Session?
+      @resolver_options: Hash[Symbol, untyped]
+
+      def state: () -> String
+
+      def current_selector=: (Selector s) -> void
+
+      def current_session=: (Session s) -> void
+
+      def closed?: () -> bool
+
+      def early_resolve: (Connection connection) -> bool
+
+      def lazy_resolve: (Connection connection) -> void
+
+      private
+
+      def nolookup_resolve: (String hostname, Options options) -> Array[Entry]?
+
+      def initialize: (singleton(Native) | singleton(HTTPS) resolver_type, Options options) -> void
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/resolver/native.rbs

@@ -0,0 +1,76 @@
+module HTTPX
+  module Resolver
+    class Native < Resolver
+      extend Forwardable
+      include _ToIO
+
+      DEFAULTS: Hash[Symbol, untyped]
+      DNS_PORT: Integer
+
+      @options: Options
+      @ns_index: Integer
+      @nameserver: Array[String]
+      @socket_type: :udp | :tcp
+      @ndots: Integer
+      @start_timeout: Float?
+      @search: Array[String]
+      @_timeouts: Array[interval]
+      @timeouts: Hash[String, Array[interval]]
+      @queries: Hash[String, Connection]
+      @connections: Array[Connection]
+      @read_buffer: String
+      @write_buffer: Buffer
+      @large_packet: Buffer?
+      @io: UDP | TCP
+      @name: String?
+      @timer: Timers::Timer?
+
+      attr_reader state: Symbol
+
+      def call: () -> void
+
+      def interests: () -> (:r | :w | nil)
+
+      def <<: (Connection) -> void
+
+      def timeout: () -> interval?
+
+      def handle_socket_timeout: (interval interval) -> void
+
+      def on_io_error: (IOError error) -> void
+
+      private
+
+      def initialize: (ip_family family, options options) -> void
+
+      def calculate_interests: () -> (:r | :w | nil)
+
+      def consume: () -> void
+
+      def schedule_retry: () -> void
+
+      def do_retry: (String host, Connection connection, interval interval) -> void
+
+      def dread: (Integer) -> void
+               | () -> void
+
+      def dwrite: () -> void
+
+      def parse: (String) -> void
+
+      def generate_candidates: (String) -> Array[String]
+
+      def build_socket: () -> (UDP | TCP)
+
+      def downgrade_socket: () -> void
+
+      def transition: (Symbol nextstate) -> void
+
+      def reset_query: () -> void
+
+      def reset_hostname: (String hostname, ?connection: Connection, ?reset_candidates: bool) -> void
+
+      def close_or_resolve: () -> void
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/resolver/resolver.rbs

@@ -0,0 +1,65 @@
+module HTTPX
+  module Resolver
+    class Resolver
+      include Loggable
+
+      include _Selectable
+
+      RECORD_TYPES: Hash[ip_family, singleton(Resolv::DNS::Resource)]
+
+      FAMILY_TYPES: Hash[singleton(Resolv::DNS::Resource), String]
+
+      attr_reader family: ip_family
+
+      attr_reader options: Options
+
+      attr_writer current_selector: Selector?
+
+      attr_writer current_session: Session?
+
+      attr_accessor multi: Multi?
+
+      @record_type: singleton(Resolv::DNS::Resource)
+      @resolver_options: Hash[Symbol, untyped]
+      @connections: Array[Connection]
+
+      def close: () -> void
+
+      def closed?: () -> bool
+
+      def empty?: () -> bool
+
+      def each_connection: () { (Connection connection) -> void } -> void
+
+      def emit_addresses: (Connection connection, ip_family family, Array[ipaddr], ?bool early_resolve) -> void
+
+      def handle_error: (ResolveError | StandardError) -> void
+
+      def self.multi?: () -> bool
+
+      def early_resolve: (Connection connection, ?hostname: String) -> bool
+
+      def lazy_resolve: (Connection connection) -> void
+
+      private
+
+      def resolve: (?Connection connection, ?String hostname) -> void
+
+      def emit_resolved_connection: (Connection connection, Array[Entry] addresses, bool early_resolve) -> void
+
+      def initialize: (ip_family family, Options options) -> void
+
+      def resolve_connection: (Connection connection) -> void
+
+      def emit_connection_error: (Connection connection, StandardError error) -> void
+
+      def emit_resolve_error: (Connection connection, ?String hostname, ?StandardError) -> void
+
+      def resolve_error: (String hostname, ?StandardError?) -> (ResolveError | ResolveTimeoutError)
+
+      def close_or_resolve: () -> void
+
+      def disconnect: () -> void
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/resolver/system.rbs

@@ -0,0 +1,37 @@
+module HTTPX
+  module Resolver
+    class System < Resolver
+      RESOLV_ERRORS: Array[singleton(StandardError)] # ResolvError
+      DONE: 1
+      ERROR: 2
+
+      class AddrinfoTimeoutError < StandardError
+      end
+
+      @resolver: Resolv::DNS
+      @_timeouts: Array[interval]
+      @timeouts: Hash[String, Array[interval]]
+      @queries: Array[[ip_family, Connection]]
+      @ips: Array[[ip_family, Connection, (Array[Addrinfo] | StandardError)]]
+      @pipe_mutex: Thread::Mutex
+      @pipe_read: IO
+      @pipe_write: IO
+
+      attr_reader state: Symbol
+
+      def initialize: (Options options) -> void
+
+      private
+
+      def transition: (Symbol nextstate) -> void
+
+      def consume: () -> void
+
+      def async_resolve: (Connection connection, String hostname, String scheme) -> void
+
+      def __addrinfo_resolve: (String host, String scheme) -> Array[Addrinfo]
+
+      def close_or_resolve: () -> void
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/resolver.rbs

@@ -0,0 +1,36 @@
+module HTTPX
+  type ipaddr = String | IPAddr | Resolv::IPv4 | Resolver::Entry
+
+  type resolver_type = singleton(HTTPX::Resolver::Resolver)
+
+  module Resolver
+
+    type dns_resource = singleton(Resolv::DNS::Resource)
+
+    type dns_result = { "name" => String, "TTL" => Numeric, "alias" => String }
+                    | { "name" => String, "TTL" => Numeric, "data" => String }
+
+    RESOLVE_TIMEOUT: Array[Integer]
+
+    self.@identifier_mutex: Thread::Mutex
+    self.@identifier: Integer
+    self.@hosts_resolver: Resolv::Hosts
+    self.@supported_ip_families: Array[Integer]
+
+    type dns_decoding_response = [:ok, Array[dns_result]] | [:decode_error, Resolv::DNS::DecodeError] | [:retriable_error | :dns_error, Integer] | Symbol
+
+    def self?.supported_ip_families: () -> Array[ip_family]
+
+    def self?.generate_id: () -> Integer
+
+    def self?.encode_dns_query: (String hostname, ?type: dns_resource, ?message_id: Integer) -> String
+
+    def self?.decode_dns_answer: (String) -> dns_decoding_response
+
+    private
+
+    def self?.id_synchronize: () { () -> void } -> void
+
+    def find_supported_ip_families: () -> Array[Integer]
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/response/body.rbs

@@ -0,0 +1,52 @@
+module HTTPX
+  class Response::Body
+    include _Reader
+    include _ToS
+    include _ToStr
+
+    attr_reader encoding: Encoding
+    attr_reader encodings: Array[String]
+
+    attr_reader buffer: Response::Buffer?
+
+    @response: Response
+    @headers: Headers
+    @options: Options
+    @state: :idle | :memory | :buffer | :closed
+    @window_size: Integer
+    @length: Integer
+    @reader: Response::Buffer?
+    @inflaters: Array[Transcoder::_Inflater]
+
+    def initialize: (Response, Options) -> void
+
+    def closed?: () -> bool
+
+    def write:(String chunk) -> Integer?
+
+    def filename: () -> String?
+
+    def bytesize: () -> Integer
+
+    def each: () { (String) -> void } -> void
+            | () -> Enumerable[String]
+
+    def empty?: () -> bool
+
+    def copy_to: (String | File | _Writer destination) -> void
+
+    def close: () -> void
+
+    def rewind: () -> void
+
+    private
+
+    def initialize_inflaters: () -> void
+
+    def self.initialize_inflater_by_encoding: (Encoding | String encoding, Response response, ?bytesize: Integer) -> (Object & Transcoder::_Inflater)
+
+    def decode_chunk: (String chunk) -> String
+
+    def transition: (Symbol nextstate) -> void
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/response/buffer.rbs

@@ -0,0 +1,23 @@
+module HTTPX
+  class Response::Buffer
+    attr_reader buffer: StringIO | Tempfile
+
+    @threshold_size: Integer
+    @bytesize: Integer
+    @encoding: Encoding
+
+    def initialize: (threshold_size: Integer, ?bytesize: Integer, ?encoding: Encoding) -> void
+
+    def size: () -> Integer
+
+    def write: (String chunk) -> Integer
+
+    def to_s: () -> String
+
+    def close: () -> void
+
+    private
+
+    def try_upgrade_buffer: () -> void
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/response.rbs

@@ -0,0 +1,109 @@
+module HTTPX
+  interface _Response
+    def <<: (String data) -> void
+
+    def finished?: () -> bool
+
+    def finish!: () -> void
+
+    def raise_for_status: () -> self
+
+    def error: () -> StandardError?
+  end
+
+  class Response
+    extend Forwardable
+    include Callbacks
+
+    include _Response
+    include _ToS
+    include _Reader
+
+    attr_reader status: Integer
+    attr_reader headers: Headers
+    attr_reader body: Body
+    attr_reader version: String
+
+    @options: Options
+    @request: Request
+    @content_type: ContentType
+    @content_length: Integer?
+    @finished: bool
+
+    def copy_to: (_ToPath | _Writer destination) -> void
+
+    def close: () -> void
+
+    def uri: () -> URI::Generic
+
+    def peer_address: () -> (String | IPAddr)?
+
+    def merge_headers: (_Each[[String, headers_value]]) -> void
+
+    def bodyless?: () -> bool
+
+    def content_type: () -> ContentType
+
+    def content_length: () -> Integer?
+
+    def complete?: () -> bool
+
+    def json: (?JSON::options opts) -> untyped
+
+    def form: () -> Hash[String, untyped]
+
+    def initialize: (Request request, String | Integer status, String version, headers?) -> void
+
+    private
+
+    def decode:(Transcoder::_Decode transcoder, ?untyped options) -> untyped
+  end
+
+  class ContentType
+    MIME_TYPE_RE: Regexp
+    CHARSET_RE: Regexp
+
+    @header_value: String?
+    @mime_type: String?
+    @charset: String?
+    @initialized: bool
+
+    def mime_type: () -> String?
+
+    def charset: () -> String?
+
+    private
+
+    def initialize: (String? header_value) -> void
+
+    def load: () -> void
+  end
+
+  class ErrorResponse
+    include _Response
+    include _Reader
+    include Loggable
+    extend Forwardable
+
+    @options: Options
+    @error: Exception
+
+    %a{pure} attr_reader request: Request
+
+    %a{pure} attr_reader response: Response?
+
+    def status: () -> (Integer | _ToS)
+
+    def uri: () -> URI::Generic
+
+    def peer_address: () -> (String | IPAddr)?
+
+    def close: () -> void
+
+    private
+
+    def initialize: (Request, Exception) -> untyped
+  end
+
+  type response = Response | ErrorResponse
+end