cybrid_api_id_ruby 0.129.1137 → 0.129.1138

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

@@ -0,0 +1,61 @@
+module HTTPX
+  module Plugins
+    module FiberConcurrency
+      module InstanceMethods
+      end
+
+      module RequestMethods
+        attr_reader context: Fiber?
+
+        def set_context!: () -> void
+
+        def current_context?: () -> boolish
+      end
+
+      module ConnectionMethods
+
+        def current_context?: () -> boolish
+
+        def send: (request request) -> void
+
+        private
+
+        def backlog?: () -> bool
+      end
+
+      module HTTP1Methods
+      end
+
+      module HTTP2Methods
+        @contexts: Hash[Fiber, Set[Request]]
+
+        private
+
+        def add_to_context: (request request) -> void
+
+        def clear_from_context: (request request) -> void
+      end
+
+      module NativeResolverMethods
+      end
+
+      module SystemResolverMethods
+      end
+
+      module FiberConcurrencyH2C
+        module HTTP2Methods
+        end
+      end
+
+       module FiberConcurrencyStream
+        module StreamResponseMethods
+          def close: () -> void
+        end
+      end
+
+      type request = Request & RequestMethods
+    end
+
+    type sessionFiberConcurrency = Session & FiberConcurrency::InstanceMethods
+  end
+end

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

@@ -0,0 +1,47 @@
+module HTTPX
+  InsecureRedirectError: singleton(Error)
+
+  module Plugins
+    module FollowRedirects
+      MAX_REDIRECTS: Integer
+      REDIRECT_STATUS: Range[Integer]
+      REQUEST_BODY_HEADERS: Array[String]
+
+      type redirect_request = Request & RequestMethods
+
+      interface _FollowRedirectsOptions
+        def max_redirects: () -> Integer?
+
+        def follow_insecure_redirects: () -> bool?
+
+        def allow_auth_to_other_origins: () -> bool?
+
+        def redirect_on: () -> (^(http_uri) -> boolish | nil)
+      end
+
+      def self.extra_options: (Options) -> (Options & _FollowRedirectsOptions)
+
+      module InstanceMethods
+        def max_redirects: (_ToI) -> instance
+
+        def handle_after_redirect_request: (http_uri original_uri, http_uri redirect_uri, Request request, Options & _FollowRedirectsOptions options) -> void
+
+        def __get_location_from_response: (Response) -> http_uri
+      end
+
+      module RequestMethods
+        attr_accessor root_request: (Request & RequestMethods)?
+
+        @redirect_request: redirect_request
+
+        def redirect_request: () -> redirect_request
+
+        def redirect_request=: (redirect_request req) -> void
+
+        def max_redirects: () -> Integer
+      end
+    end
+
+    type sessionFollowRedirects = Session & FollowRedirects::InstanceMethods
+  end
+end

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

@@ -0,0 +1,23 @@
+module HTTPX
+  module Plugins
+    module GRPC
+      class Call
+        attr_writer decoder: _Callable
+
+        @response: Response | StreamResponse
+        @consumed: bool
+        @grpc_response: Enumerator[String] | String
+
+        def metadata: () -> headers
+
+        def trailing_metadata: () -> headers?
+
+        private
+
+        def initialize: (Response | StreamResponse response) -> untyped
+
+        def grpc_response: () -> grpc_response
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module HTTPX
+  module Transcoder
+    module GRPCEncoding
+
+      def self?.encode: (body_encoder body, compressed: bool) -> Deflater
+
+      def self?.decode: (Response | StreamResponse response) -> Inflater
+
+      class Deflater
+        attr_reader content_type: String
+
+        @body: BodyReader
+        @compressed: bool
+
+        def initialize: (body_encoder body, compressed: bool) -> void
+
+        def bytesize: () -> (Integer | Float)
+
+        def read: (?int? length, ?string outbuf) -> String?
+      end
+
+      class Inflater
+        @response: Response
+        @grpc_encodings: Array[String]
+
+        def initialize: (Response | StreamResponse response) -> void
+
+        def call: (String message) ?{ (String) -> void } -> String
+
+        private
+
+        def grpc_encodings: () -> Array[String]
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+
+module HTTPX
+  module Plugins
+    module GRPC
+      module Message
+        def self?.unary: (response) -> grpc_message
+
+        def self?.stream: (StreamResponse) { (String) -> void } -> void
+                        | (StreamResponse) -> Enumerable[String]
+
+        def self?.cancel: (Request) -> void
+
+        def self?.verify_status: (StreamResponse | response) -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module HTTPX
+  class GRPCError < Error
+    attr_reader status: Integer
+    attr_reader details: String
+    attr_reader metadata: headers
+  end
+
+  module Plugins
+    module GRPC
+      DEADLINE: Integer
+      MARSHAL_METHOD: Symbol
+      UNMARSHAL_METHOD: Symbol
+      HEADERS: Hash[String, String]
+
+      type compression_option = bool | String
+      type rpc_def = [String, untyped, untyped, Hash[Symbol, untyped]]
+
+      type grpc_message = String | _Each[String]
+
+      type grpc_request = untyped | _Each[untyped]
+      type grpc_response = untyped | _Each[untyped]
+
+      type credentials = Proc
+
+      interface _GRPCOptions
+        def grpc_service: () -> String?
+
+        def grpc_compression: () -> compression_option?
+
+        def grpc_rpcs: () -> Hash[String, rpc_def]?
+
+        def grpc_deadline: () -> Integer?
+
+        def call_credentials: () -> credentials?
+      end
+
+      def self.extra_options: (Options) -> (Options & _GRPCOptions)
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      module ResponseMethods
+        attr_reader trailing_metadata: Hash[String, untyped]
+
+        def encoders: () -> Array[String | Encoding]
+      end
+
+      module InstanceMethods
+        def with_channel_credentials: (String ca_path, ?String? key, ?String? cert, **untyped) -> instance
+
+        def rpc: (_ToS rpc_name, untyped input, untyped output, **untyped) -> instance
+
+        def build_stub: (string origin, ?service: _ToS, ?compression: compression_option) -> instance
+
+        def execute:  (_ToS rpc_method, grpc_message input, ?deadline: Integer, ?metadata: headers_input, **untyped) -> Call
+
+        private
+
+        def rpc_execute: (_ToS rpc_method, grpc_request input, **untyped) -> Call
+
+        def build_grpc_request: (string rpc_method, grpc_message input, ?deadline: Integer, ?metadata?: headers_input, **untyped) -> Request
+      end
+    end
+
+    type grpcSession = Session & GRPC::InstanceMethods
+  end
+end

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

@@ -0,0 +1,27 @@
+module HTTPX
+  module Plugins
+    module H2C
+      VALID_H2C_VERBS: Array[verb]
+
+      def self.load_dependencies: (*untyped) -> void
+      def self.configure: (singleton(Session)) -> void
+      def self.call: (Connection, Request, response) -> void
+
+      interface _H2COptions
+        def h2c_class: () -> (singleton(Connection::HTTP2) & H2CParser)
+      end
+
+      module H2CParser
+        def upgrade: (Request, Response) -> void
+      end
+
+      module RequestMethods
+        def valid_h2c_verb?: () -> bool
+      end
+
+      module ConnectionMethods
+        def upgrade_to_h2c: (Request, Response) -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module HTTPX
+  module Plugins
+    module NTLMAuth
+
+      interface _NTLMOptions
+        def ntlm: () -> Authentication::Ntlm?
+      end
+
+      def self.extra_options: (Options) -> (Options & _NTLMOptions)
+
+      def self.load_dependencies: (singleton(Session) klass) -> void
+
+      module InstanceMethods
+        def ntlm_auth: (string user, string password, ?string? domain) -> instance
+      end
+
+    end
+
+    type sessionNTLMAuth = sessionAuth & NTLMAuth::InstanceMethods
+  end
+end

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

@@ -0,0 +1,36 @@
+module HTTPX
+  module Plugins
+    module NTLMV2Auth
+      class Authenticator
+        @user: String
+        @password: String
+        @domain: String?
+
+        def can_authenticate?: (String? www_authenticate) -> boolish
+
+        def authenticate: (Request request, String authenticate) -> String
+
+        def negotiate: () -> String
+
+        private
+
+        def initialize: (string user, string password, ?domain: String?) -> void
+      end
+
+      interface _NTLMV2Options
+        def ntlm: () -> Authentication?
+      end
+
+      def self.extra_options: (Options) -> (Options & _NTLMV2Options)
+
+      def self.load_dependencies: (singleton(Session) klass) -> void
+
+      module InstanceMethods
+        def ntlm_auth: (string user, string password, ?string? domain) -> instance
+      end
+
+    end
+
+    type sessionNTLMV2Auth = sessionAuth & NTLMV2Auth::InstanceMethods
+  end
+end

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

@@ -0,0 +1,97 @@
+module HTTPX
+  module Plugins
+    #
+    # https://gitlab.com/os85/httpx/wikis/OAuth
+    #
+    module OAuth
+      def self.load_dependencies: (singleton(Session) klass) -> void
+
+      type grant_type = "client_credentials" | "refresh_token"
+
+      type token_auth_method = "client_secret_basic" | "client_secret_post"
+
+      SUPPORTED_GRANT_TYPES: ::Array[grant_type]
+
+      SUPPORTED_AUTH_METHODS: ::Array[token_auth_method]
+
+      class OAuthSession
+        attr_reader access_token: String?
+
+        attr_reader refresh_token: String?
+
+        @issuer: http_uri
+        @grant_type: grant_type
+        @client_id: String
+        @client_secret: String
+        @token_endpoint: http_uri?
+        @scope: Array[String]?
+        @audience: String?
+        @token_endpoint_auth_method: String?
+
+        def initialize: (
+          issuer: uri,
+          client_id: String,
+          client_secret: String,
+          ?access_token: String?,
+          ?refresh_token: String?,
+          ?scope: (Array[String] | String)?,
+          ?token_endpoint: String?,
+          ?grant_type: String?,
+          ?token_endpoint_auth_method: ::String,
+          ?audience: ::String
+        ) -> void
+
+        def token_endpoint: () -> uri
+
+        def token_endpoint_auth_method: () -> String
+
+        def reset!: () -> void
+
+        def fetch_access_token: (sessionOAuth http) -> String
+
+        def merge: (instance | Hash[untyped, untyped] other) -> instance
+
+        private
+
+
+        def load: (sessionOAuth http) -> void
+      end
+
+      interface _OAuthOptions
+        def oauth_session: () -> OAuthSession?
+
+        def oauth_options: () -> {
+          issuer: uri,
+          client_id: String,
+          client_secret: String,
+          ?access_token: String?,
+          ?refresh_token: String?,
+          ?scope: (Array[String] | String)?,
+          ?token_endpoint: String?,
+          ?response_type: String?,
+          ?grant_type: String?,
+          ?token_endpoint_auth_method: ::String,
+          ?audience: ::String
+        }?
+      end
+
+      module InstanceMethods
+        attr_reader oauth_session: OAuthSession
+        @options: Options & _OAuthOptions
+
+        def oauth_auth: (**untyped args) -> instance
+
+        def with_access_token: () -> instance
+
+        def refresh_oauth_tokens!: () -> void
+      end
+
+      module OAuthRetries
+        module InstanceMethods
+        end
+      end
+    end
+
+    type sessionOAuth = Session & Auth::InstanceMethods & OAuth::InstanceMethods
+  end
+end

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

@@ -0,0 +1,21 @@
+module HTTPX
+  module Plugins
+    module Persistent
+      SAFE_REONNECTABLE_ERRORS: Array[singleton(StandardError)]
+
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      def self.extra_options: (Options) -> (Options)
+
+      module InstanceMethods
+        private
+
+        def reconnectable_error?: (StandardError error) -> bool
+
+        def safe_reconnectable_error?: (StandardError error) -> bool
+      end
+    end
+
+    type sessionPersistent = sessionFiberConcurrency & Persistent::InstanceMethods
+  end
+end

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

@@ -0,0 +1,32 @@
+module HTTPX
+  module Plugins
+    module Proxy
+      module HTTP
+
+        module InstanceMethods
+          def with_proxy_basic_auth: (Hash[Symbol, untyped] opts) -> instance
+
+          def with_proxy_digest_auth: (Hash[Symbol, untyped] opts) -> instance
+
+          def with_proxy_ntlm_auth: (Hash[Symbol, untyped] opts) -> instance
+        end
+
+        module ConnectionMethods
+          @tunnel_parser: Connection::HTTP1 | Connection::HTTP2
+
+          def __http_proxy_connect: (Connection::_Parser parser) ->  void
+          def __http_on_connect: (top, Response) ->  void
+        end
+
+        module ProxyParser
+        end
+
+        class ConnectRequest < Request
+          def initialize: (generic_uri uri, Options options) -> void
+        end
+      end
+    end
+
+    type httpProxy = Session & Proxy::HTTP::InstanceMethods
+  end
+end

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

@@ -0,0 +1,41 @@
+module HTTPX
+  class Socks4Error < ProxyError
+  end
+
+  module Plugins
+    module Proxy
+      module Socks4
+        VERSION: Integer
+        CONNECT: Integer
+        GRANTED: Integer
+        PROTOCOLS: Array[String]
+
+        module ConnectionMethods
+          def __socks4_proxy_connect: () ->  void
+          def __socks4_on_packet: (String packet) ->  void
+          def on_socks4_error: (string) -> void
+        end
+
+        class SocksParser
+          include HTTPX::Callbacks
+
+          @buffer: Buffer
+          @options: Options
+
+          def close: () -> void
+          def consume: (*untyped) -> void
+          def empty: () -> bool
+          def <<: (string) -> void
+
+          private
+
+          def initialize: (Buffer buffer, Options options) -> untyped
+        end
+
+        module Packet
+          def self?.connect: (Parameters, uri) -> String
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module HTTPX
+  class Socks5Error < ProxyError
+  end
+
+  module Plugins
+    module Proxy
+      module Socks5
+        VERSION: Integer
+        NOAUTH: Integer
+        PASSWD: Integer
+        NONE: Integer
+        CONNECT: Integer
+        IPV4: Integer
+        DOMAIN: Integer
+        IPV6: Integer
+        SUCCESS: Integer
+
+        module ConnectionMethods
+          def __socks5_proxy_connect: () ->  void
+          def __socks5_on_packet: (String packet) ->  void
+          def __socks5_check_version: (int) -> void
+          def __on_socks5_error: (string) -> void
+        end
+
+        class SocksParser
+          include HTTPX::Callbacks
+
+          @buffer: Buffer
+          @options: Options
+
+          def close: () -> void
+          def consume: (*untyped) -> void
+          def empty: () -> bool
+          def <<: (string) -> void
+
+          private
+
+          def initialize: (Buffer buffer, Options options) -> untyped
+        end
+
+        module Packet
+          def self?.negotiate: (Parameters parameters) -> String
+          def self?.authenticate: (Parameters parameters) -> String
+          def self?.connect: (uri uri) -> String
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module HTTPX
+  module Plugins
+    module Proxy
+      module SSH
+        def self.load_dependencies: (singleton(Session)) -> void
+
+        module InstanceMethods
+          private
+
+          def build_gateway_socket: (int, http_uri, Options) ->  _ToIO
+        end
+      end
+    end
+
+
+    type sessionSSHProxy = Proxy::InstanceMethods & Proxy::SSH::InstanceMethods
+  end
+end

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

@@ -0,0 +1,71 @@
+module HTTPX
+  class ProxyError < ConnectionError
+  end
+
+  class ProxySSL < SSL
+    attr_reader proxy_io: TCP | SSL
+  end
+
+  module Plugins
+    interface _Authenticator
+      def authenticate: (Request request, String authenticate) -> String
+    end
+
+    module Proxy
+      class ProxyConnectionError < ProxyError
+      end
+
+      PROXY_ERRORS: Array[singleton(StandardError)]
+
+      class Parameters
+        attr_reader uri: URI::Generic?
+        attr_reader username: String?
+        attr_reader password: String?
+        attr_reader scheme: String?
+        attr_reader no_proxy: Array[String]?
+
+        @ns: Integer
+        @uris: Array[URI::Generic | String]
+        @authenticator: _Authenticator
+
+        def shift: () -> void
+
+        def can_authenticate?: (*untyped) -> boolish
+
+        def authenticate: (*untyped) -> String?
+
+        def ==: (untyped) -> bool
+
+        private
+
+        def initialize: (?uri: generic_uri | Array[generic_uri], ?scheme: String, ?username: String, ?password: String, ?no_proxy: Array[generic_uri] | generic_uri, **untyped) -> void
+
+        def infer_default_auth_scheme: (URI::Generic uri) -> String?
+
+        def load_authenticator: (String scheme, String username, String password, **untyped) -> _Authenticator
+      end
+
+      def self.configure: (singleton(Session)) -> void
+
+      interface _ProxyOptions
+        def proxy: () -> Parameters?
+      end
+
+      def self.extra_options: (Options) -> (Options & _ProxyOptions)
+
+      module ConnectionMethods
+        @proxy_uri: generic_uri
+      end
+
+      module InstanceMethods
+        @__proxy_uris: Array[generic_uri]
+
+        private
+
+        def proxy_error?: (Request request, response, Options options) -> bool
+      end
+    end
+
+    type sessionProxy = Session & Proxy::InstanceMethods
+  end
+end

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

@@ -0,0 +1,23 @@
+module HTTPX
+  module Plugins
+    module PushPromise
+      module ResponseMethods
+        @__pushed: bool?
+
+        def pushed?: () -> boolish
+        def mark_as_pushed!: () -> void
+      end
+
+      module InstanceMethods
+        @promise_headers: Hash[::HTTP2::Stream, Request]?
+        private
+
+        def promise_headers: () -> Hash[::HTTP2::Stream, Request]
+        def __on_promise_request: (Connection::HTTP2, ::HTTP2::Stream, headers_input) -> void
+        def __on_promise_response: (Connection::HTTP2, ::HTTP2::Stream, headers_input) -> void
+      end
+    end
+
+    type sessionPushPromise = Session & PushPromise::InstanceMethods
+  end
+end