cybrid_api_id_ruby 0.129.1137 → 0.129.1138

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

@@ -0,0 +1,80 @@
+module HTTPX
+  interface _Selectable
+    def state: () -> Symbol
+
+    def to_io: () -> IO
+
+    def call: () -> void
+
+    def initial_call: () -> void
+
+    def interests: () -> io_interests?
+
+    def timeout: () -> interval?
+
+    def handle_socket_timeout: (interval interval) -> void
+
+    def on_error: (StandardError) -> void
+
+    def on_io_error: (IOError error) -> void
+
+    def force_close: (?bool delete_pending) -> void
+
+    def terminate: () -> void
+  end
+
+  class Selector
+
+    type selectable = Resolver::Resolver | Connection | (Object & _Loggable & _Selectable)
+
+    type io_select_selectable = (selectable | Array[selectable])?
+
+    extend Forwardable
+
+    READABLE: Array[io_interests]
+    WRITABLE: Array[io_interests]
+
+    @timers: Timers
+
+    @selectables: Array[selectable]
+    @is_timer_interval: bool
+
+    def each: () -> ::Enumerator[selectable, self]
+            | () { (selectable) -> void } -> self
+
+    def next_tick: () -> void
+
+    def terminate: () -> void
+
+    def find_resolver: (Options options) -> Resolver::Resolver?
+
+    def find_connection: (http_uri request_uri, Options options) -> Connection?
+
+    def each_connection: () { (Connection) -> void} -> void
+                       | () -> Enumerable[Connection]
+
+    def find_mergeable_connection: (Connection connection) -> Connection?
+
+    def empty?: () -> bool
+
+    def register: (selectable io) -> void
+
+    def deregister: (selectable io) -> selectable?
+
+    private
+
+    def initialize: () -> void
+
+    def select: (interval? interval) { (selectable) -> void } -> void
+
+    def select_many: (io_select_selectable r, io_select_selectable w, interval? interval) { (selectable) -> void } -> void
+
+    def select_one: (selectable io, io_interests interests, interval? interval) { (selectable) -> void } -> void
+
+    def next_timeout: () -> interval?
+
+    def rw_wait: (io_select_selectable IO, interval? interval) -> untyped?
+  end
+
+  type io_interests = :r | :w | :rw
+end

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

@@ -0,0 +1,104 @@
+module HTTPX
+  class Session
+    include Loggable
+    include Chainable
+
+    EMPTY_HASH: Hash[untyped, untyped]
+
+    @options: Options
+
+    # returns the HTTPX::Pool object which manages the networking required to
+    # perform requests.
+    @pool: Pool
+
+    @persistent: bool
+    @wrapped: bool
+    @closing: bool
+
+    type resolver = Resolver::Multi | Resolver::Resolver
+
+    def wrap: () { (instance) -> void } -> void
+
+    def close: (?Selector selector) -> void
+
+    def build_request: (verb verb, generic_uri uri, ?request_params params, ?Options options) -> Request
+
+    def select_connection: (Connection connection, Selector selector) -> void
+
+    def pin: (resolver | Connection conn_or_resolver, Selector selector) -> void
+
+    def deselect_connection: (Connection connection, Selector selector, ?bool cloned) -> void
+
+    def select_resolver: (Resolver::Resolver resolver, Selector selector) -> void
+
+    def deselect_resolver: (Resolver::Resolver resolver, Selector selector) -> void
+
+    def try_clone_connection: (Connection connection, Selector selector, Integer? family) -> Connection
+
+    def find_connection: (http_uri request_uri, Selector selector, Options options) -> Connection
+
+    private
+
+    def initialize: (?options) { (self) -> void } -> void
+                  | (?options) -> void
+
+    def selector_close: (Selector close) -> void
+
+    def deactivate: (Selector selector) -> void
+
+    def on_promise: (untyped, untyped) -> void
+
+    def fetch_response: (Request request, Selector selector, Options options) -> response?
+
+    def send_request: (Request request, Selector selector, ?Options options) -> void
+
+    def set_request_callbacks: (Request request) -> void
+
+    def build_requests: (verb, uri, request_params) -> Array[Request]
+                      | (Array[[verb, uri] | [verb, uri, request_params]], ?request_params) -> Array[Request]
+                      | (verb, _Each[[uri] | [uri, request_params]], request_params) -> Array[Request]
+
+    def do_init_connection: (Connection connection, Selector selector) -> void
+
+    def send_requests: (*Request) -> Array[response]
+
+    def receive_requests: (Array[Request] requests, Selector selector) -> Array[response]
+
+    def early_resolve: (resolver resolver, Connection connection) -> bool
+
+    def resolve_connection: (Connection connection, Selector selector) -> void
+
+    def on_resolver_connection: (Connection connection, Selector selector) -> void
+
+    def on_resolver_close: (Resolver::Resolver resolver, Selector selector) -> void
+
+    def find_resolver_for: (Connection connection, Selector selector) -> resolver
+
+    def coalesce_connections: (Connection conn1, Connection conn2, Selector selector, bool from_pool) -> void
+
+    def get_current_selector: () -> Selector?
+                            | () { () -> Selector } -> Selector
+
+    def set_current_selector: (Selector? selector) -> void
+
+    def selector_store: () -> Hash[instance, Selector]
+
+    def thread_selector_store: (Thread th) -> Hash[instance, Selector]?
+
+    attr_reader self.default_options: Options
+    self.@plugins: Array[Module]
+
+    def self.plugin: (Symbol | Module plugin, ?options? options) ?{ (Class) -> void } -> singleton(Session)
+
+
+    INSTANCES: Hash[Session, Session]
+
+    def self.after_fork: () -> void
+
+    module ForkTracker
+      def _fork: () -> void
+    end
+  end
+
+  S: singleton(Session)
+end

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

@@ -0,0 +1,58 @@
+module HTTPX
+  class Timers
+    type callback = ^() -> void
+
+    @intervals: Array[Interval]
+    @next_interval_at: Float
+
+    def after: (interval interval_in_secs, ^() -> void) -> Timer
+             | (interval interval_in_secs) { () -> void } -> Timer
+
+    def wait_interval: () -> interval?
+
+    def fire: (?TimeoutError error) -> void
+
+    def initialize: () -> void
+
+    def empty?: () -> bool
+
+    private
+
+    def drop_elapsed!: (Numeric elapsed_time) -> void
+
+    class Interval
+      include Comparable
+
+      attr_reader interval: interval
+
+      @callbacks: Array[callback]
+
+      def to_f: () -> Float
+
+      def <<: (callback) -> void
+
+      def delete: (callback) -> void
+
+      def elapse: (Numeric elapsed) -> Numeric
+
+      def elapsed?: (?Numeric elapsed_time) -> bool
+
+      def no_callbacks?: () -> bool
+
+      private
+
+      def initialize: (interval interval) -> void
+    end
+
+    class Timer
+      @interval: Interval
+      @callback: callback
+
+      attr_accessor label: Symbol?
+
+      def initialize: (Interval interval, callback callback) -> void
+
+      def cancel: () -> void
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module HTTPX
+  module Transcoder
+    module Body
+      class Error < HTTPX::Error
+      end
+
+      class Encoder #  < SimpleDelegator
+        @body: Object & bodyIO
+
+        def bytesize: () -> (Integer | Float)
+
+        def content_type: () -> String
+
+        def to_s: () -> String
+
+        private
+
+        def initialize: (untyped body) -> untyped
+      end
+
+      def self?.encode: (bodyIO body) -> Encoder
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module HTTPX::Transcoder
+  module Chunker
+    CRLF: String
+
+    class Error < HTTPX::Error
+    end
+
+    def self?.encode: (_Each[String] chunks) -> Encoder
+
+    class Encoder
+      @raw: Object & _Each[String]
+
+      def each: () { (String) -> void } -> void
+              | () -> Enumerator[String, void]
+
+      private
+
+      def initialize: (_Each[String] chunks) -> void
+    end
+
+    class Decoder
+      extend Forwardable
+      include _ToS
+
+      @buffer: String
+      @chunk_length: Integer
+      @chunk_buffer: String
+      @finished: bool
+      @state: Symbol
+      @trailers: bool
+
+      def each: () { (String) -> void } -> void
+
+      def finished?: () -> bool
+
+      def empty?: () -> bool
+
+      def <<: (string) -> void
+
+      def clear: () -> void
+
+      private
+
+      def initialize: (String, ?bool) -> void
+
+      def nextstate: (Symbol) -> void
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module HTTPX
+  module Transcoder
+    module Deflate
+      def self?.encode: (_Encoder body) -> Deflater
+      def self?.decode: (Response body, ?bytesize: Integer) -> GZIP::Inflater
+
+      class Deflater < Transcoder::Deflater
+        @deflater: Zlib::Deflate
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module HTTPX::Transcoder
+  type form_value = string
+
+  type form_nested_value = form_value | _ToAry[form_value] | _ToHash[string, form_value]
+
+  type urlencoded_input = Enumerable[[_ToS, form_nested_value]]
+
+  module Form
+    PARAM_DEPTH_LIMIT: Integer
+
+    def self?.encode: (urlencoded_input form) -> Encoder
+
+    def self?.decode: (HTTPX::Response response) -> _Decoder
+
+    class Encoder
+      extend Forwardable
+      include _ToS
+
+      @raw: String
+
+      def bytesize: () -> Integer
+
+      def content_type: () -> String
+
+      private
+
+      def initialize: (urlencoded_input form) -> untyped
+    end
+
+    module Decoder
+      def self?.call: (HTTPX::Response response, *untyped) -> Hash[String, untyped]
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module HTTPX
+  module Transcoder
+    module GZIP
+      def self?.encode: (body_encoder body) -> Deflater
+      def self?.decode: (Response response, ?bytesize: Integer) -> Inflater
+
+      class Deflater < Transcoder::Deflater
+        include _Writer
+
+        @compressed_chunk: String
+        @deflater: Zlib::GzipWriter
+
+        private
+
+        def compressed_chunk: () -> String
+      end
+
+      class Inflater
+        @inflater: Zlib::Inflate
+        @bytesize: Integer | Float
+
+        def initialize: (Integer | Float bytesize) -> void
+
+        def call: (String chunk) -> String
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module HTTPX::Transcoder
+  module JSON
+    JSON_REGEX: Regexp
+
+    def self?.encode: (_ToJson json) -> Encoder
+    def self?.decode: (HTTPX::Response response) -> _Decoder
+
+    def self?.json_load: (string source, ?JSON::options) -> untyped
+    def self?.json_dump: (_ToJson obj, *untyped) -> String
+
+    class Encoder
+      extend Forwardable
+
+      @raw: String
+      @charset: String
+
+      def bytesize: () -> Integer
+
+      def content_type: () -> String
+
+      def to_s: () -> String
+
+      private
+
+      def initialize: (_ToJson json) -> void
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module HTTPX
+  module Transcoder
+    module Multipart
+      interface _MultipartInput
+        def filename: () -> String
+        def content_type: () -> String
+        def read: (?int? length, ?string? output) -> String?
+      end
+
+      type multipart_value = string | Pathname | File | Tempfile | _Reader
+
+      type record_multipart_value = { content_type: String, filename: String, body: multipart_value } |
+                                    { content_type: String, body: multipart_value }
+
+      type multipart_nested_value = multipart_value | _ToAry[multipart_value] | _ToHash[string, multipart_value]
+
+      type multipart_input = Enumerable[[_ToS, Multipart::multipart_nested_value]]
+
+      def self?.encode: (multipart_input form_data) -> Multipart::Encoder
+
+      def self?.multipart?: (urlencoded_input | multipart_input form_data) -> bool
+
+      def self?.multipart_value?: (multipart_nested_value value) -> bool
+
+      def self?.normalize_keys: [U] (_ToS key, _ToAry[untyped] | _ToHash[_ToS, untyped] | untyped value, ?_KeyNormalizer transcoder) { (String, ?untyped) -> U } -> U
+
+      class Encoder
+        @boundary: String
+        @part_index: Integer
+        @buffer: String
+
+        @form: Enumerable[[Symbol | string, Object & multipart_nested_value]]
+        @parts: Array[Object & _Reader]
+
+        attr_reader bytesize: Integer
+
+        def content_type: () -> String
+
+        def to_s: () -> String
+
+        def read: (?int? length, ?string? buffer) -> String?
+
+        def rewind: () -> void
+
+        private
+
+        def to_parts: (multipart_input multipart_data) -> Array[_Reader]
+
+        def initialize: (multipart_input multipart_data) -> untyped
+
+        def header_part: (String key, String content_type, String? filename) -> StringIO
+
+        def read_chunks: (String buffer, ?Integer? length) -> void
+
+        def read_from_part: (?Integer? max_length) -> String?
+      end
+
+      class Decoder
+        include Utils
+
+        CRLF: String
+        BOUNDARY_RE: Regexp
+        MULTIPART_CONTENT_TYPE: Regexp
+        MULTIPART_CONTENT_DISPOSITION: Regexp
+        MULTIPART_CONTENT_ID: Regexp
+        WINDOW_SIZE: Integer
+
+        @state: :idle | :part_header | :part_body | :parse_boundary | :done
+        @buffer: String
+        @parts: Hash[String, untyped]
+        @boundary: String
+        @intermediate_boundary: String
+        @current: String?
+
+        def call: (Response response, *untyped) -> Hash[String, untyped]
+
+        private
+
+        def initialize: (Response response) -> void
+
+        def parse: () -> void
+      end
+
+      class FilePart #  < SimpleDelegator
+        attr_reader original_filename: String
+        attr_reader content_type: String
+        @file: Tempfile
+
+        # @file: Tempfile
+
+        # private
+
+        def initialize: (String filename, String content_type) -> void
+      end
+
+      module Part
+        def self?.call: [U] (Object & _MultipartInput multipart_input) -> [U, String, String]
+                      | (multipart_nested_value value) -> ([StringIO, String, String?] | [File | Tempfile, String, String])
+      end
+
+      module MimeTypeDetector
+        DEFAULT_MIMETYPE: String
+
+        def self?.call: (IO | Tempfile file, String filename) -> String?
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/transcoder/utils/body_reader.rbs

@@ -0,0 +1,15 @@
+module HTTPX
+  module Transcoder
+    class BodyReader
+      @body: Object & (_Reader | _Each[String])
+
+      def initialize: (body_encoder body) -> void
+
+      def bytesize: () -> (Integer | Float)
+
+      def read: (?int? length, ?string? outbuf) -> String?
+
+      def close: () -> void
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/transcoder/utils/deflater.rbs

@@ -0,0 +1,30 @@
+module HTTPX
+  module Transcoder
+    class Deflater
+      extend Forwardable
+
+      @body: BodyReader
+      @buffer: Response::Buffer?
+      @closed: bool
+
+      attr_reader content_type: String
+
+      def initialize: (body_encoder body) -> void
+
+      def bytesize: () -> (Integer | Float)
+
+      def read: (?int? length, ?string? outbuf) -> String?
+
+      def close: () -> void
+
+      def deflate: (String? chunk) -> String?
+
+      def rewind: () -> void
+
+      private
+
+      def buffer_deflate!: () -> void
+
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module HTTPX
+  type bodyIO = _Reader | _Each[String] | _ToS
+
+  type body_encoder = (Transcoder::_Encoder & _ToS) | (Transcoder::_Encoder & _Reader) | (Transcoder::_Encoder & _Each[String])
+
+  interface _KeyNormalizer
+    def normalize_keys: [U] (_ToS key, _ToAry[untyped] | _ToHash[_ToS, untyped] | untyped value, ?_KeyNormalizer transcoder) { (String, ?untyped) -> U } -> U
+  end
+
+  module Transcoder
+    def self?.normalize_keys: [U] (_ToS key, _ToAry[untyped] | _ToHash[_ToS, untyped] | untyped value, ?_KeyNormalizer transcoder) { (String, ?untyped) -> U } -> U
+
+    def self?.normalize_query: (Hash[String, untyped] params, String name, String v, Integer depth) -> void
+
+    def self?.params_hash_has_key?: (Hash[String, untyped], String key) -> bool
+
+    interface _Encode
+      def encode: (untyped payload) -> body_encoder
+    end
+
+    interface _Decode
+      def decode: (HTTPX::Response response) -> _Decoder
+    end
+
+    interface _Encoder
+      def bytesize: () -> (Integer | Float)
+
+      def content_type: () -> String
+    end
+
+    interface _Decoder
+      def call: (Response response, *untyped) -> untyped
+    end
+
+    interface _Inflater
+      def call: (String chunk) -> String
+    end
+
+    interface _Deflater
+      def initialize: (Response body) -> void
+
+      def deflate: () -> void
+
+      def call: (StringIO | File buffer, ?chunk_size: Integer) ?{ (String chunk) -> void } -> void
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module HTTPX
+  module Utils
+    TOKEN: Regexp
+    VALUE: Regexp
+    FILENAME_REGEX: Regexp
+    FILENAME_EXTENSION_REGEX: Regexp
+    URIParser: URI::RFC2396_Parser
+
+    def self?.parse_retry_after: (String) -> interval
+
+    def self?.now: () -> Float
+
+    def self?.elapsed_time: (Integer | Float monotonic_time) -> Float
+
+    def self?.to_uri: (generic_uri uri) -> URI::Generic
+
+    def self?.get_filename: (String header) -> String?
+
+    def self?.in_ractor?: () -> bool
+  end
+end

data/vendor/bundle/ruby/4.0.0/specifications/http-2-1.2.3.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+# stub: http-2 1.2.3 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "http-2".freeze
+  s.version = "1.2.3".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "bug_tracker_uri" => "https://github.com/igrigorik/http-2/issues", "changelog_uri" => "https://github.com/igrigorik/http-2/blob/main/CHANGELOG.md", "homepage_uri" => "https://github.com/igrigorik/http-2", "rubygems_mfa_required" => "true", "source_code_uri" => "https://github.com/igrigorik/http-2" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Tiago Cardoso".freeze, "Ilya Grigorik".freeze, "Kaoru Maeda".freeze]
+  s.date = "1980-01-02"
+  s.description = "Pure-ruby HTTP 2.0 protocol implementation".freeze
+  s.email = ["cardoso_tiago@hotmail.com".freeze, "ilya@igvita.com".freeze]
+  s.homepage = "https://github.com/igrigorik/http-2".freeze
+  s.licenses = ["MIT".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.7.0".freeze)
+  s.rubygems_version = "4.0.16".freeze
+  s.summary = "Pure-ruby HTTP 2.0 protocol implementation".freeze
+
+  s.installed_by_version = "4.0.14".freeze
+end