cybrid_api_id_ruby 0.129.1137 → 0.129.1138

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

@@ -0,0 +1,33 @@
+module HTTPX
+
+  class TLSError < OpenSSL::SSL::SSLError
+  end
+
+  class SSL < TCP
+    TLS_OPTIONS: Hash[Symbol, untyped]
+
+    @ctx: OpenSSL::SSL::SSLContext
+    @verify_hostname: bool
+    @sni_hostname: String
+    @session_new_cb: (^(OpenSSL::SSL::Session sess) -> void)?
+
+    attr_writer ssl_session: OpenSSL::SSL::Session?
+
+    # TODO: lift when https://github.com/ruby/rbs/issues/1497 fixed
+    # def initialize: (URI::Generic origin, Array[Resolver::Entry]? addresses, options options) ?{ (self) -> void } -> void
+
+    def session_new_cb: { (OpenSSL::SSL::Session sess) -> void } -> void
+    def can_verify_peer?: () -> bool
+
+    def verify_hostname: (String host) -> bool
+
+    def ssl_session_expired?: () -> boolish
+
+    # :nocov:
+    def try_ssl_connect: () -> void
+
+    private
+
+    def init_session_new_cb: () -> void
+  end
+end

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

@@ -0,0 +1,74 @@
+module HTTPX
+  class TCP
+    include Loggable
+
+    attr_reader ip: Resolver::Entry?
+
+    attr_reader port: Integer
+
+    attr_reader addresses: Array[Resolver::Entry]
+
+    attr_reader state: Symbol
+
+    attr_reader interests: io_interests
+
+    alias host ip
+
+    @io: Socket
+
+    @hostname: String
+
+    @options: Options
+
+    @fallback_protocol: String
+
+    @keep_open: bool
+
+    @ip_index: Integer
+
+    # TODO: lift when https://github.com/ruby/rbs/issues/1497 fixed
+    def initialize: (URI::Generic origin, Array[Resolver::Entry]? addresses, Options options) ?{ (instance) -> void } -> void
+
+    def add_addresses: (Array[Resolver::Entry] addrs) -> void
+
+    def addresses?: () -> bool
+
+    def to_io: () -> IO
+
+    def protocol: () -> String
+
+    def connect: () -> void
+
+    private
+
+    # :nocov:
+    def try_connect: () -> void
+
+    public
+
+    def read: (Integer size, Buffer | String buffer) -> (0 | nil | untyped)
+
+    def write: (Buffer buffer) -> Integer?
+
+    def close: () -> void
+
+    def can_disconnect?: () -> bool
+
+    def connected?: () -> bool
+
+    def closed?: () -> bool
+
+    # :nocov:
+    def inspect: () -> ::String
+
+    private
+
+    def build_socket: () -> Socket
+
+    def transition: (Symbol nextstate) -> void
+
+    def do_transition: (Symbol nextstate) -> void
+
+    def log_transition_state: (Symbol nextstate) -> String
+  end
+end

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

@@ -0,0 +1,25 @@
+module HTTPX
+  class UDP
+    include Loggable
+
+    @host: String
+    @port: Integer
+    @io: UDPSocket
+    @options: Options
+
+    def initialize: (String ip, Integer port, Options options) -> void
+
+    def to_io: () -> IO
+
+    def connect: () -> void
+
+    def connected?: () -> bool
+
+    # :nocov:
+    def close: () -> void
+
+    def read: (Integer size, String buffer) -> Integer?
+
+    def write: (Buffer buffer) -> Integer?
+  end
+end

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

@@ -0,0 +1,26 @@
+module HTTPX
+  class UNIX < TCP
+
+    attr_reader path: String
+
+    alias host path
+
+    @hostname: String
+
+    @options: Options
+
+    @fallback_protocol: String
+
+    @keep_open: bool
+
+    @io: Socket
+
+    def initialize: (http_uri origin, String? path, Options options) -> void
+
+    def connect: () -> void
+
+    private
+
+    def build_socket: () -> Socket
+  end
+end

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

@@ -0,0 +1,3 @@
+module HTTPX
+  type io_type = "udp" | "tcp" | "ssl" | "unix"
+end

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

@@ -0,0 +1,29 @@
+module HTTPX
+  interface _IOLogger
+    def <<: (string?) -> void
+  end
+
+  interface _Loggable
+    def log: (?level: Integer?, ?color: Symbol?, ?debug_level: Integer, ?debug: _IOLogger?) { () -> String } -> void
+  end
+
+  module Loggable
+    USE_DEBUG_LOG: bool
+
+    COLORS: Hash[Symbol, Integer]
+
+    def self.log_identifiers: () -> String
+
+    def log: (?level: Integer?, ?color: Symbol?, ?debug_level: Integer, ?debug: _IOLogger?) { () -> String } -> void
+
+    def log_exception: (Exception error, ?level: Integer, ?color: Symbol, ?debug_level: Integer, ?debug: _IOLogger?) -> void
+
+    private
+
+    def log_redact_headers: (_ToS text) -> String
+
+    def log_redact_body: (_ToS text) -> String
+
+    def log_redact: (_ToS text, ?bool? should_redact) -> String
+  end
+end

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

@@ -0,0 +1,232 @@
+module HTTPX
+  class Options
+    # include _ToHash
+
+    type maybe_unbounded = Integer | Float # because infinity
+
+    BUFFER_SIZE: Integer
+    WINDOW_SIZE: Integer
+    MAX_BODY_THRESHOLD_SIZE: Integer
+    CONNECT_TIMEOUT: Integer
+    READ_TIMEOUT: Integer
+    WRITE_TIMEOUT: Integer
+    REQUEST_TIMEOUT: Integer
+    TOTAL_REQUEST_TIMEOUT: Integer
+    OPERATION_TIMEOUT: Integer
+    KEEP_ALIVE_TIMEOUT: Integer
+    PING_TIMEOUT: Integer
+    SETTINGS_TIMEOUT: Integer
+    CLOSE_HANDSHAKE_TIMEOUT: Integer
+    SET_TEMPORARY_NAME: ^(Class klass, ?Symbol pl) -> void
+
+    DEFAULT_OPTIONS: Hash[Symbol, untyped]
+    REQUEST_BODY_IVARS: Array[Symbol]
+    RESOLVER_IVARS: Array[Symbol]
+    RESOLVER_TYPES: Array[Symbol]
+    USER_AGENT: String
+
+    type timeout_type = :connect_timeout | :settings_timeout | :close_handshake_timeout | :operation_timeout | :keep_alive_timeout | :read_timeout | :write_timeout | :total_request_timeout | :request_timeout | :ping_timeout
+    type timeout = Hash[timeout_type, interval?]
+    type redact_value = :headers | :body | bool
+    type resolver_cache_option = :memory | :file | (Object & Resolver::_Cache)
+
+    def self.new: (?options) -> instance
+
+    attr_reader self.options_names: Array[Symbol]
+
+    # headers
+    attr_reader uri: URI?
+
+    # headers
+    attr_reader headers: headers?
+
+    # timeout
+    attr_reader timeout: timeout
+
+    # http2_settings
+    attr_reader http2_settings: Hash[Symbol, Integer | bool]
+
+    # max_concurrent_requests
+    attr_reader max_concurrent_requests: maybe_unbounded?
+
+    # max_requests
+    attr_reader max_requests: maybe_unbounded?
+
+    # window_size
+    attr_reader window_size: Integer
+
+    # buffer_size
+    attr_reader buffer_size: Integer
+
+    # body_threshold_size
+    attr_reader body_threshold_size: Integer
+
+    # max_response_headers
+    attr_reader max_response_headers: Integer
+
+    # max_response_header_value_size
+    attr_reader max_response_header_value_size: maybe_unbounded?
+
+    # max_response_body_size
+    attr_reader max_response_body_size: maybe_unbounded
+
+    # transport
+    attr_reader transport: io_type | nil
+
+    # addresses
+    attr_reader addresses: Array[Resolver::Entry]?
+
+    # supported_compression_formats
+    attr_reader supported_compression_formats: Array[String]
+
+    # compress_request_body
+    attr_reader compress_request_body: bool
+
+    # decompress_response_body
+    attr_reader decompress_response_body: bool
+
+    # origin
+    attr_reader origin: URI::Generic?
+
+    # base_path
+    attr_reader base_path: String?
+
+    # classes
+    attr_reader resolver_native_class: singleton(Resolver::Native)
+
+    attr_reader resolver_system_class: singleton(Resolver::System)
+
+    attr_reader resolver_https_class: singleton(Resolver::HTTPS)
+
+    attr_reader http1_class: singleton(Connection::HTTP1)
+
+    attr_reader http2_class: singleton(Connection::HTTP2)
+
+    attr_reader connection_class: singleton(Connection)
+
+    attr_reader pool_class: singleton(Pool)
+
+    attr_reader request_class: singleton(Request)
+
+    attr_reader response_class: singleton(Response)
+
+    attr_reader headers_class: singleton(Headers)
+
+    attr_reader request_body_class: singleton(Request::Body)
+
+    attr_reader response_body_class: singleton(Response::Body)
+
+    attr_reader options_class: singleton(Options)
+
+    attr_reader ssl: Hash[Symbol, untyped]
+
+    type external_io = TCPSocket | OpenSSL::SSL::SSLSocket | UNIXSocket
+
+    type io_option = external_io | Hash[String, external_io]
+
+    attr_reader io: io_option?
+
+    # fallback_protocol
+    attr_reader fallback_protocol: String
+
+    # debug
+    attr_reader debug: _IOLogger?
+
+    # debug_level
+    attr_reader debug_level: Integer
+
+    # persistent
+    attr_reader persistent: bool
+
+    # close_on_fork
+    attr_reader close_on_fork: bool
+
+    # resolver_options
+    attr_reader resolver_options: Hash[Symbol, untyped]
+
+    # resolver_options
+    attr_reader pool_options: pool_options
+
+    # ip_families
+    attr_reader ip_families: Array[ip_family]?
+
+    @resolver_cache: resolver_cache_option
+
+    def resolver_class: () -> singleton(Resolver::Resolver)
+
+    def resolver_cache: () -> (Object & Resolver::_Cache)
+
+    def ==: (Options other) -> bool
+
+    def connection_options_match?: (Options other, ?Array[Symbol] ignore_ivars) -> bool
+
+    def resolver_options_match?: (Options other) -> bool
+
+    def merge: (Object & _ToHash[Symbol, untyped] other) -> (instance | self)
+
+    def to_hash: () -> Hash[Symbol, untyped]
+
+    def extend_with_plugin_classes: (Module pl) -> void
+
+    private
+
+    def initialize: (?options options) -> void
+
+    def do_initialize: () -> void
+
+    def access_option: (Hash[Symbol, untyped] | Object | nil obj, Symbol k, Hash[Symbol, Symbol]? ivar_map) -> untyped
+
+    # integer
+    def option_max_concurrent_requests: (int value) -> maybe_unbounded
+    def option_max_requests: (int value) -> maybe_unbounded
+    def option_window_size: (int value) -> Integer
+    def option_buffer_size: (int value) -> Integer
+    def option_body_threshold_size: (int value) -> Integer
+    def option_debug_level: (int value) -> Integer
+
+    # to hash
+    def option_ssl: (_ToHash[Symbol, untyped] value) -> Hash[Symbol, untyped]
+    def option_http2_settings: (_ToHash[Symbol, untyped] value) -> Hash[Symbol, untyped]
+    def option_resolver_options: (_ToHash[Symbol, untyped] value) -> Hash[Symbol, untyped]
+    def option_pool_options: (_ToHash[Symbol, untyped] value) -> Hash[Symbol, untyped]
+
+    # no transform
+    def option_request_class: (singleton(Request) value) -> singleton(Request)
+    def option_response_class: (singleton(Response) value) -> singleton(Response)
+    def option_headers_class: (singleton(Headers) value) -> singleton(Headers)
+    def option_request_body_class: (singleton(Request::Body) value) -> singleton(Request::Body)
+    def option_response_body_class: (singleton(Response::Body) value) -> singleton(Response::Body)
+    def option_connection_class: (singleton(Connection) value) -> singleton(Connection)
+    def option_options_class: (singleton(Options) value) -> singleton(Options)
+    def option_pool_class: (singleton(Pool) value) -> singleton(Pool)
+    def option_resolver_class: (Symbol | resolver_type value) -> (Symbol | resolver_type)
+    def option_io: (io_option value) -> io_option
+    def option_fallback_protocol: (String value) -> String
+    def option_debug: (_IOLogger value) -> _IOLogger
+    def option_debug_redact: (redact_value value) -> redact_value
+    def option_compress_request_body: (bool value) -> bool
+    def option_decompress_response_body: (bool value) -> bool
+    def option_persistent: (bool value) -> bool
+    def option_close_on_fork: (bool value) -> bool
+
+    def option_resolver_cache: (resolver_cache_option value) -> resolver_cache_option
+
+    def option_origin: (http_uri | String value) -> http_uri
+
+    def option_base_path: (_ToStr value) -> String
+
+    def option_headers: (headers_input | Headers value) -> Headers
+
+    def option_timeout: (_ToHash[timeout_type, interval?]) -> timeout
+
+    def option_supported_compression_formats: (_ToS | _ToAry[_ToS] value) -> Array[String]
+
+    def option_transport: (_ToS value) -> String
+
+    def option_addresses: (ipaddr | _ToAry[ipaddr] value) -> Array[ipaddr]
+
+    def option_ip_families: (ip_family | _ToAry[ip_family] value) -> Array[ip_family]
+  end
+
+  type options = Options | Hash[Symbol, untyped]
+end

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

@@ -0,0 +1,61 @@
+module HTTPX
+  module Parser
+    class Error < HTTPX::Error
+    end
+
+    type parsed_headers = Hash[String, Array[String]]
+
+    interface _HTTP1Events
+
+      def on_start: () -> void
+      def on_headers: (parsed_headers headers) -> void
+      def on_trailers: (parsed_headers trailers) -> void
+      def on_data: (String data) -> void
+      def on_complete: () -> void
+    end
+
+    class HTTP1
+      VERSIONS: Array[String]
+
+      attr_reader status_code: Integer
+      attr_reader http_version: [Integer, Integer]
+      attr_reader headers: parsed_headers
+
+      @observer: _HTTP1Events
+      @state: Symbol
+      @buffer: String | Transcoder::Chunker::Decoder
+      @content_type: String?
+      @content_length: Integer
+      @_has_trailers: bool
+      @upgrade: bool
+      @max_headers: Options::maybe_unbounded
+      @max_header_value_size: Options::maybe_unbounded?
+
+      def <<: (string chunk) -> void
+
+      def reset!: () -> void
+
+      def upgrade?: () -> bool
+
+      def upgrade_data: () -> String
+
+      private
+
+      def initialize: (_HTTP1Events observer, Options::maybe_unbounded max_headers, Options::maybe_unbounded? max_header_value_size) -> void
+
+      def nextstate: (Symbol state) -> void
+
+      def no_more_data?: () -> bool
+
+      def parse: () -> void
+
+      def parse_data: () -> void
+
+      def parse_headers: () -> void
+
+      def parse_headline: () -> void
+
+      def prepare_data: (parsed_headers headers) -> void
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/plugins/auth/basic.rbs

@@ -0,0 +1,17 @@
+module HTTPX
+  module Plugins
+    module Authentication
+      class Basic
+        @user: String
+        @password: String
+
+        def authenticate: (*untyped) -> String
+
+        private
+
+        def initialize: (string user, string password, **untyped) -> void
+
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/plugins/auth/digest.rbs

@@ -0,0 +1,31 @@
+module HTTPX
+  module Plugins
+    module Authentication
+      class Digest
+        Error: singleton(HTTPX::Error)
+
+
+        @user: String
+        @password: String
+        @hashed: bool
+        @nonce: Integer
+
+        def can_authenticate?: (String? authenticate) -> boolish
+
+        def authenticate: (Request request, String authenticate) -> String?
+
+        private
+
+        def generate_header: (String meth, String uri, String authenticate) -> String
+
+        def initialize: (string user, string password, ?hashed: bool, **untyped) -> void
+
+        def make_cnonce: () -> String
+
+        def next_nonce: () -> Integer
+
+        def raise_format_error: () -> void
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/plugins/auth/ntlm.rbs

@@ -0,0 +1,22 @@
+module HTTPX
+  module Plugins
+    module Authentication
+      class Ntlm
+        @user: String
+        @password: String
+        @domain: String?
+
+        def can_authenticate?: (String? authenticate) -> boolish
+
+        def authenticate: (Request request, String authenticate) -> String
+
+        def negotiate: () -> String
+
+        private
+
+        def initialize: (string user, string password, ?domain: String?) -> void
+
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/sig/plugins/auth/socks5.rbs

@@ -0,0 +1,18 @@
+module HTTPX
+  module Plugins
+    module Authentication
+      class Socks5
+        @user: String
+        @password: String
+
+        def can_authenticate?: (*untyped) -> boolish
+
+        def authenticate: (*untyped) -> String
+
+        private
+
+        def initialize: (string user, string password) -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module HTTPX
+  module Plugins
+    module Auth
+      type auth_header_value_type = String | ^(?Request request, ?bool should_regenerate) -> string
+
+      interface _AuthOptions
+        def auth_header_value: () -> auth_header_value_type?
+
+        def auth_header_type: () -> String?
+
+        def auth_header_expires_at: () -> (^(Request request) -> _ToF?)?
+
+        def auth_header_expires_in: () -> Float?
+      end
+
+      module InstanceMethods
+        @auth_header_value: String?
+        @auth_header_value_mtx: Thread::Mutex
+        @skip_auth_header_value: bool
+
+        def authorization: (?string token, ?auth_header_type: string) ?{ (?Request, ?bool) -> string } -> instance
+
+        def bearer_auth: (?string token) ?{ (Request) -> string } -> instance
+
+        def skip_auth_header: [T] { () -> T } -> T
+
+        def reset_auth_header_value!: () -> void
+
+        private
+
+        def generate_auth_token: (Request & RequestMethods request, bool should_regenerate) -> String?
+
+        def dynamic_auth_token?: (auth_header_value_type auth_header_value) -> boolish
+      end
+
+      module RequestMethods
+        attr_reader auth_token_value: String?
+
+        @auth_header_value: String?
+
+        def authorized?: () -> bool
+
+        def unauthorize!: () -> void
+
+        def authorize: (String auth_value) -> void
+      end
+
+      module AuthRetries
+        module InstanceMethods
+          private
+
+          def auth_error?: (response response, Options options) -> boolish
+        end
+      end
+    end
+
+    type sessionAuth = Session & Auth::InstanceMethods
+  end
+end

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

@@ -0,0 +1,43 @@
+module HTTPX
+  module Plugins
+    module AwsSdkAuthentication
+      class Configuration
+        attr_reader profile: String?
+
+        private
+
+        def initialize: (String? profile) -> void
+      end
+
+      class Credentials
+        @aws_credentials: untyped
+
+        include _SigV4Credentials
+
+        private
+
+        def initialize: (untyped aws_credentials) -> untyped
+      end
+
+      interface _AwsSdkOptions
+        def aws_profile: () -> String?
+      end
+
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      def self.configure: (singleton(Session)) -> void
+
+      def self.extra_options: (Options) -> (Options & _AwsSdkOptions)
+
+      def self.credentials: (String? profile) -> Credentials
+
+      def self.region: (String? profile) -> String
+
+      module InstanceMethods
+        def aws_sdk_authentication: (?credentials: Credentials, ?region: String, **untyped) -> instance
+      end
+    end
+
+    type sessionAwsSdkAuthentication = awsSigV4Session & AwsSdkAuthentication::InstanceMethods
+  end
+end