cybrid_api_organization_ruby 0.129.1137 → 0.129.1138

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

@@ -0,0 +1,18 @@
+module HTTPX
+  module Plugins
+    module Query
+      def self.subplugins: () -> Hash[Symbol, Module]
+
+      module InstanceMethods
+        def query: (uri | [uri], **untyped) -> response
+                 | (_Each[uri | [uri, request_params]], **untyped) -> Array[response]
+      end
+
+      module QueryRetries
+        module InstanceMethods
+        end
+      end
+    end
+    type sessionQuery = Session & Query::InstanceMethods
+  end
+end

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

@@ -0,0 +1,15 @@
+module HTTPX
+  module Plugins
+    module RateLimiter
+      RATE_LIMIT_CODES: Array[Integer]
+
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      module InstanceMethods
+        def rate_limit_error?: (response response) -> bool
+      end
+    end
+
+    type sessionRateLimiter = Session & RateLimiter::InstanceMethods
+  end
+end

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

@@ -0,0 +1,67 @@
+module HTTPX
+  module Plugins
+    module ResponseCache
+      CACHEABLE_VERBS: Array[verb]
+      CACHEABLE_STATUS_CODES: Array[Integer]
+      SUPPORTED_VARY_HEADERS: Array[String]
+
+      def self?.cacheable_response?: (::HTTPX::ErrorResponse | responseCacheResponse response) -> bool
+
+      def self?.not_modified?: (response response) -> bool
+
+      interface _ResponseCacheOptions
+        def supported_vary_headers: () -> Array[String]
+      end
+
+      module InstanceMethods
+        private
+
+        def match_by_vary?: (responseCacheRequest request, responseCacheResponse response) -> bool
+      end
+
+      module RequestMethods
+        attr_accessor cached_response: responseCacheResponse?
+        attr_reader options: responseCacheOptions
+
+        @response_cache_key: String
+
+        private
+
+        def cacheable_verb?: () -> bool
+      end
+
+      module ResponseMethods
+        attr_writer revalidated_at: Time
+
+        @cache_control: Array[String]?
+
+        @vary: Array[String]?
+
+        @date: Time?
+
+        def copy_from_cached!: () -> void
+
+        def fresh?: () -> bool
+
+        %a{pure} def cache_control: () -> Array[String]?
+
+        %a{pure} def vary: () -> Array[String]?
+
+        private
+
+        def age: () -> Integer
+
+        def date: () -> Time
+      end
+
+
+      type responseCacheOptions = Options & Cache::_CacheOptions & _ResponseCacheOptions
+
+      type responseCacheRequest = Request & Cache::RequestMethods & RequestMethods
+
+      type responseCacheResponse = Response & Cache::ResponseMethods & ResponseMethods
+    end
+
+    type sessionResponseCache = Session & Cache::InstanceMethods & ResponseCache::InstanceMethods
+  end
+end

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

@@ -0,0 +1,80 @@
+module HTTPX
+  module Plugins
+    module Retries
+      MAX_RETRIES: Integer
+      IDEMPOTENT_METHODS: Array[String]
+      RECONNECTABLE_ERRORS: Array[singleton(StandardError)]
+      RETRYABLE_ERRORS: Array[singleton(StandardError)]
+      DEFAULT_JITTER: ^(interval) -> interval
+      BACKOFF_ALGORITHMS: Array[Symbol]
+
+      def self?.retry_after_polynomial_backoff: (retriesRequest request, retriesResponse response) -> interval
+
+      def self?.retry_after_exponential_backoff: (retriesRequest request, retriesResponse response) -> interval
+
+      interface _RetryCallback
+        def call: (retriesResponse response) -> bool?
+      end
+
+      interface _RetriesOptions
+        def retry_after: () -> (^(retriesRequest request, retriesResponse response) -> interval | interval)?
+
+        def retry_jitter: () -> ^(interval jitter) -> interval
+
+        def max_retries: () -> Integer
+
+        def retry_change_requests: () -> boolish
+
+        def retry_on: () -> _RetryCallback?
+      end
+
+      def self.extra_options: (Options options) -> retriesOptions
+
+      module InstanceMethods
+        def max_retries: (int) -> instance
+
+        private
+
+        def fetch_response: (retriesRequest request, Selector selector, retriesOptions options) -> retriesResponse?
+
+        def retryable_request?: (retriesRequest request, retriesResponse response, retriesOptions options) -> boolish
+
+        def retryable_response?: (retriesResponse response, retriesOptions options) -> boolish
+
+        def retryable_error?: (_Exception error, Options options) -> boolish
+
+        def try_partial_retry: (retriesRequest request, retriesResponse response) -> void
+
+        def prepare_to_retry: (retriesRequest request, retriesResponse response) -> void
+
+        def can_reconnect?: (retriesRequest request, retriesResponse response) -> bool
+
+        def when_to_retry: (retriesRequest request, retriesResponse response, retriesOptions options) -> Numeric?
+      end
+
+      module RequestMethods
+        attr_reader options: retriesOptions
+
+        attr_accessor retries: Integer
+
+        attr_writer partial_response: retriesResponse?
+
+        def response=: (retriesResponse response) -> void
+      end
+
+      module ResponseMethods
+        def from_partial_response: (retriesHTTPResponse response) -> void
+      end
+
+      type retriesOptions = Options & _RetriesOptions
+
+      type retriesRequest = Request & RequestMethods
+
+      type retriesHTTPResponse = Response & ResponseMethods
+
+      type retriesResponse = retriesHTTPResponse | ErrorResponse
+    end
+
+    type sessionRetries = Session & Retries::InstanceMethods
+  end
+end

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

@@ -0,0 +1,45 @@
+module HTTPX
+  module Plugins
+    module ServerSentEvents
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      def self.subplugins: () -> Hash[Symbol, Module]
+
+      class Message
+        attr_reader data: String
+        attr_reader id: _ToS?
+        attr_reader event: _ToS?
+        attr_reader retry_after: Integer?
+
+        def initialize: (data: String, ?event: _ToS?, ?id: _ToS?, ?retry_after: Integer?) -> void
+      end
+
+      interface _ServerSentEventsOptions
+        def event_stream: () -> boolish
+      end
+
+      module InstanceMethods
+      end
+
+      module RequestMethods
+        attr_accessor last_server_sent_message: Message?
+      end
+
+      module StreamResponseMethods
+        def each_message: () { (Message) -> void } -> void
+                 | () -> Enumerable[Message]
+
+        private
+
+        def raise_format_error: (String line) -> void
+      end
+
+      module ServerSentEventsRetries
+        module InstanceMethods
+        end
+      end
+    end
+
+    type sessionServerSentEvents = Session & ServerSentEvents::InstanceMethods
+  end
+end

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

@@ -0,0 +1,30 @@
+module HTTPX
+  class ServerSideRequestForgeryError < Error
+  end
+
+  module Plugins
+    module SsrfFilter
+      IPV4_BLACKLIST: Array[IPAddr]
+
+      IPV6_BLACKLIST: Array[[IPAddr, IPAddr]]
+
+      def self?.unsafe_ip_address?: (IPAddr ipaddr) -> bool
+
+      interface _Options
+        def allowed_schemes: () -> Array[String]
+
+        def extra_unsafe_ranges: () -> Array[IPAddr]?
+
+        def safe_private_ranges: () -> Array[IPAddr]?
+      end
+
+      module InstanceMethods
+      end
+
+      module ConnectionMethods
+      end
+    end
+
+    type sessionSsrf = Session & SsrfFilter::InstanceMethods
+  end
+end

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

@@ -0,0 +1,64 @@
+module HTTPX
+  module Plugins
+    module Stream
+      STREAM_REQUEST_OPTIONS: Hash[Symbol, untyped]
+
+      interface _StreamOptions
+        def stream: () -> boolish
+
+        def retry_stream_response_class: () -> singleton(StreamResponse)
+      end
+
+      module InstanceMethods
+        @options: Options & _StreamOptions
+
+        private
+
+        def request: (*Request, **untyped?) -> (response | Array[response] | StreamResponse)
+                   | (*untyped, **untyped?) -> (response | Array[response] | StreamResponse)
+      end
+
+      module RequestMethods
+        attr_accessor stream: StreamResponse?
+      end
+
+      module ResponseMethods
+        def stream: () -> StreamResponse?
+      end
+
+      module ResponseBodyMethods
+        @stream: StreamResponse?
+      end
+    end
+
+    type sessionStream = Session & Stream::InstanceMethods
+  end
+
+  class StreamResponse
+    include _ToS
+
+    type streamRequest = Request & Plugins::Stream::RequestMethods
+
+    attr_reader request: streamRequest
+    @options: Options & Plugins::Stream::_StreamOptions
+
+    @session: Plugins::sessionStream
+    @response_enum: Enumerator[String]?
+    @buffered_chunks: Array[String]
+    @on_chunk: ^(String) -> void | nil
+
+    def each: () { (String) -> void } -> void
+            | () -> Enumerable[String]
+
+    def each_line: () { (String) -> void } -> void
+                 | () -> Enumerable[String]
+
+    def on_chunk: (string) -> void
+
+    def initialize: (streamRequest, Plugins::sessionStream) -> void
+
+    private
+
+    def response: () -> response
+  end
+end

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

@@ -0,0 +1,67 @@
+module HTTPX
+  module Plugins
+    module StreamBidi
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      def self.extra_options: (Options) -> (Options)
+
+      module HTTP2Methods
+        @lock: Thread::Mutex
+
+        private
+
+        def handle_stream: (::HTTP2::Stream stream, Request & RequestMethods request) -> void
+
+        def end_stream?: (Request & RequestMethods request, String? next_chunk) -> void
+      end
+
+      class BidiBuffer < Buffer
+        @buffer_mutex: Thread::Mutex
+        @oob_mutex: Thread::Mutex
+        @oob_buffer: String
+
+        def rebuffer: () -> void
+      end
+
+      class Signal
+        attr_reader error: Exception?
+
+        @closed: bool
+        @pipe_read: IO
+        @pipe_write: IO
+
+        include _Selectable
+
+        def wakeup: () -> void
+
+        def inflight?: () -> bool
+      end
+
+      module InstanceMethods
+        @signal: Signal
+      end
+
+      module RequestMethods
+        attr_accessor headers_sent: bool
+
+        @closed: bool
+        @flush_buffer_on_body_cb: ^() -> void | nil
+        @mutex: Thread::Mutex
+
+        def flush_buffer_on_body: { () -> void } -> void
+
+        def closed?: () -> bool
+      end
+
+      module RequestBodyMethods
+      end
+
+      module ConnectionMethods
+        @write_buffer: BidiBuffer
+      end
+
+    end
+
+    type sessionStreamBidi = Session & StreamBidi::InstanceMethods
+  end
+end

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

@@ -0,0 +1,41 @@
+module HTTPX
+  module Plugins
+    module Tracing
+      interface _Tracer
+        def enabled?: (retriesRequest request) -> boolish
+
+        def start: (retriesRequest request) -> void
+
+        def reset: (retriesRequest request) -> void
+
+        def finish: (retriesRequest request, response response) -> void
+      end
+
+      class Wrapper
+        include _Tracer
+
+        attr_reader tracers: Array[_Tracer]
+
+        def initialize: (*_Tracer tracers) -> void
+
+        def merge: (instance) -> void
+      end
+
+      interface _RetriesOptions
+        def tracer: () -> _Tracer
+      end
+
+      module RequestMethods
+        attr_accessor init_time: Time?
+      end
+
+      module ConnectionMethods
+        @init_time: Time?
+      end
+
+      type retriesRequest = Request & RequestMethods
+    end
+
+    type sessionTracing = Session
+  end
+end

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

@@ -0,0 +1,9 @@
+module HTTPX
+  module Plugins
+    module H2
+      module ConnectionMethods
+        def upgrade_to_h2: () -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module HTTPX
+  module Plugins
+    module Upgrade
+      interface _Upgrader
+        def call: (Connection connection, Request request, Response response) -> void
+      end
+
+      def self.configure: (singleton(Session)) -> void
+
+      interface _UpgradeOptions
+        def upgrade_handlers: () -> Hash[String, _Upgrader]
+      end
+
+      def self.extra_options: (Options) -> (Options & _UpgradeOptions)
+
+      module InstanceMethods
+      end
+
+      module ConnectionMethods
+        attr_reader upgrade_protocol: String?
+        attr_reader hijacked: boolish
+
+        def hijack_io: () -> void
+      end
+    end
+
+    type sessionUpgrade = Session & Upgrade::InstanceMethods
+  end
+end

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

@@ -0,0 +1,23 @@
+module HTTPX
+  module Plugins
+    module WebDav
+      module InstanceMethods
+        def copy: (String src, String dst) -> (Response | ErrorResponse)
+
+        def move: (String src, String dst) -> (Response | ErrorResponse)
+
+        def lock: (String path, ?timeout: interval) ?{ (Response response) -> void } -> (Response | ErrorResponse)
+
+        def unlock: (String path, String? lock_token) -> (Response | ErrorResponse)
+
+        def mkcol: (String dir) -> Response
+
+        def propfind: (String path, ?(:acl | String) xml) -> Response
+
+        def proppatch: (String path, String xml) -> Response
+      end
+    end
+
+    type sessionWebDav = Session & WebDav::InstanceMethods
+  end
+end

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

@@ -0,0 +1,37 @@
+module HTTPX
+  module Plugins
+    module XML
+      MIME_TYPES: Regexp
+
+      module Transcoder
+        def self?.encode: (Nokogiri::XML::Node | String xml) -> Encoder
+        def self?.decode: (HTTPX::Response response) -> HTTPX::Transcoder::_Decoder
+
+        class Encoder
+          @raw: Nokogiri::XML::Node | String # can be nokogiri object
+
+          def content_type: () -> String
+
+          def bytesize: () -> (Integer | Float)
+
+          def to_s: () -> String
+
+          private
+
+          def initialize: (Nokogiri::XML::Node | String xml) -> void
+        end
+      end
+
+      module InstanceMethods
+      end
+
+      module ResponseMethods
+        def xml: () -> Nokogiri::XML::Node
+      end
+
+      module RequestBodyClassMethods
+      end
+    end
+    type sessionXML = Session & XML::InstanceMethods
+  end
+end

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

@@ -0,0 +1,51 @@
+module HTTPX
+  type pool_options = {
+    max_connections_per_origin: Integer?,
+    pool_timeout: interval?
+  }
+
+  class Pool
+    POOL_TIMEOUT: Integer
+
+    type resolver_manager = Resolver::Multi | Resolver::System
+
+    @max_connections: Integer
+    @max_connections_per_origin: Integer
+    @pool_timeout: interval
+    @options: Options
+    @resolvers: Hash[Class, Array[resolver_manager]]
+    @resolver_mtx: Thread::Mutex
+    @connections: Array[Connection]
+    @connection_mtx: Thread::Mutex
+    @connections_counter: Integer
+    @max_connections_cond: ConditionVariable
+    @origin_counters: Hash[String, Integer]
+    @origin_conds: Hash[String, ConditionVariable]
+
+    def pop_connection: () -> Connection?
+
+    def checkout_connection: (http_uri uri, Options options) -> Connection
+
+    def checkin_connection: (Connection connection) -> void
+
+    def checkout_mergeable_connection: (Connection connection) -> Connection?
+
+    def reset_resolvers: () -> void
+
+    def checkout_resolver: (Options options) -> resolver_manager
+
+    def checkin_resolver: (Resolver::Multi | Resolver::Resolver resolver) -> void
+
+    private
+
+    def initialize: (pool_options options) -> void
+
+    def acquire_connection: (http_uri uri, Options options) -> Connection?
+
+    def checkout_new_connection: (http_uri uri, Options options) -> Connection
+
+    def checkout_new_resolver: (Class resolver_type, Options options) -> resolver_manager
+
+    def drop_connection: (?Connection connection) -> Connection?
+  end
+end

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

@@ -0,0 +1,5 @@
+module HTTPX
+  module Punycode
+    def self?.encode_hostname: (String) -> String
+  end
+end

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

@@ -0,0 +1,34 @@
+module HTTPX
+  class Request::Body
+    attr_reader options: Options
+
+    @headers: Headers
+    @body: body_encoder?
+    @unbounded_body: bool
+
+    def initialize: (Headers h, Options options, **untyped) -> void
+
+    def each: () { (String) -> void } -> void
+            | () -> Enumerable[String]
+
+    def rewind: () -> void
+
+    def empty?: () -> bool
+
+    def bytesize: () -> (Integer | Float)
+
+    def stream: (Transcoder::_Encoder) -> bodyIO
+
+    def unbounded_body?: () -> bool
+
+    def chunked?: () -> bool
+
+    def chunk!: () -> void
+
+    private
+
+    def self.initialize_body: (Hash[Symbol, untyped] params) -> body_encoder?
+
+    def self.initialize_deflater_body: (body_encoder body, Encoding | String encoding) -> body_encoder
+  end
+end