cybrid_api_organization_ruby 0.129.1137 → 0.129.1138

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

@@ -0,0 +1,78 @@
+module HTTPX
+  module Plugins
+
+    interface _SigV4Credentials
+      def username: () -> String
+      def password: () -> String
+      def security_token: () -> String?
+    end
+
+    module AWSSigV4
+
+      class Credentials < Struct[[String, String, String?]]
+        attr_reader username: String
+        attr_reader password: String
+        attr_reader security_token: String?
+      end
+
+
+      class Signer
+        @credentials: Object & _SigV4Credentials
+        @service: String
+        @region: String
+        @unsigned_headers: Set[String]
+        @apply_checksum_header: bool
+        @provider_prefix: String
+        @header_provider_field: String
+        @algorithm: String
+
+        def sign!: (Request & RequestMethods request) -> void
+
+        def self.new: (instance) -> instance
+                    | (**untyped params) -> instance
+        private
+
+        def initialize: (
+          service: String,
+          region: String,
+          ?credentials: _SigV4Credentials,
+          ?username: String,
+          ?password: String,
+          ?security_token: String,
+          ?provider_prefix: String,
+          ?header_provider_field: String,
+          ?unsigned_headers: Array[String],
+          ?apply_checksum_header: bool,
+          ?algorithm: String
+        ) -> untyped
+
+
+        def hexdigest: (Request::Body value) -> String
+
+        def hmac: (String key, String value) -> String
+
+        def hexhmac: (String key, String value) -> String
+      end
+
+
+      interface _SigV4Options
+        def sigv4_signer: () -> Signer?
+      end
+
+      def self.extra_options: (Options) -> (Options & _SigV4Options)
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      module InstanceMethods
+        def aws_sigv4_authentication: (**untyped) -> instance
+      end
+
+      module RequestMethods
+        def canonical_path: () -> String
+
+        def canonical_query: () -> String
+      end
+    end
+
+    type awsSigV4Session = Session & AWSSigV4::InstanceMethods
+  end
+end

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

@@ -0,0 +1,15 @@
+module HTTPX
+  module Plugins
+    module BasicAuth
+      def self.load_dependencies: (singleton(Session) klass) -> void
+
+      def self.configure: (singleton(Session) klass) -> void
+
+      module InstanceMethods
+        def basic_auth: (string user, string password) -> instance
+      end
+    end
+
+    type sessionBasicAuth = sessionAuth & BasicAuth::InstanceMethods
+  end
+end

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

@@ -0,0 +1,27 @@
+module HTTPX
+  module Plugins
+    module Brotli
+      def self?.load_dependencies: (singleton(Session)) -> void
+
+      def self?.encode: (body_encoder body) -> Deflater
+
+      def self?.decode: (HTTPX::Response response, ?bytesize: Integer | Float) -> Inflater
+
+      class Error < ::HTTPX::Error
+      end
+
+      class Deflater < Transcoder::Deflater
+        @compressor: ::Brotli::Compressor
+      end
+
+      class Inflater
+        @inflater: ::Brotli::Decompressor
+        @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/plugins/cache/file_store.rbs

@@ -0,0 +1,21 @@
+module HTTPX
+  module Plugins
+    module Cache
+      class FileStore
+        CRLF: String
+
+        @dir: Pathname
+
+        include _CacheStore
+
+        def initialize: (?path dir) -> void
+
+        private
+
+        def file_path: (cacheRequest request) -> Pathname
+
+        def read_from_file: (cacheRequest request, File f) -> cacheResponse?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module HTTPX
+  module Plugins
+    module Cache
+      class Store
+        @store: Hash[String, cacheResponse]
+
+        @store_mutex: Thread::Mutex
+
+        include _CacheStore
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module HTTPX
+  module Plugins
+    module Cache
+      interface _CacheStore
+        def get: (cacheRequest request) -> cacheResponse?
+
+        def set: (cacheRequest request, cacheResponse response) -> void
+
+        def clear: () -> void
+      end
+
+      interface _CacheOptions
+        def cache_key: () -> String?
+
+        def cacheable_request: () -> ^(cacheRequest request) -> boolish
+
+        def cacheable_response: () -> ^(cacheRequest request, cacheResponse response) -> boolish
+
+        def valid_cached_response: () -> ^(cacheRequest request, cacheResponse response) -> boolish
+
+         def response_cache_store: () -> Store
+      end
+
+      module InstanceMethods
+        def clear_response_cache: () -> void
+
+        private
+
+        def cacheable_request?: (cacheRequest request) -> boolish
+
+        def cacheable_response?: (cacheRequest request, cacheResponse response) -> boolish
+
+        def valid_cached_response?: (cacheRequest request, cacheResponse cached_response) -> boolish
+
+        def prepare_cache: (cacheRequest request) -> void
+
+        def retrieve_cached_response: (cacheRequest request) -> cacheResponse?
+      end
+
+      module RequestMethods
+        attr_accessor cached_response: cacheResponse?
+        attr_reader options: cacheOptions
+
+        def response_cache_key: () -> String?
+      end
+
+      module ResponseMethods
+        attr_writer original_request: cacheRequest
+
+        @cached: bool
+
+        def original_request: () -> cacheRequest?
+
+        def cached?: () -> bool
+
+        def mark_as_cached!: () -> void
+      end
+
+
+      type cacheOptions = Options & _CacheOptions
+
+      type cacheRequest = Request & RequestMethods
+
+      type cacheResponse = Response & ResponseMethods
+    end
+
+    type sessionCache = Session & Cache::InstanceMethods
+  end
+end

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

@@ -0,0 +1,41 @@
+module HTTPX
+  module Plugins
+    module Callbacks
+      class CallbackError < Exception
+      end
+
+      module InstanceMethods
+        include HTTPX::Callbacks
+
+        type socket = TCPSocket | OpenSSL::SSL::SSLSocket | UNIXSocket
+
+        def on_connection_opened: () { (http_uri origin, socket sock) -> void } -> self
+
+        def on_connection_closed: () { (http_uri origin) -> void } -> self
+
+        def on_request_error: () { (Request request, StandardError error) -> void } -> self
+
+        def on_request_started: () { (Request request) -> void } -> self
+
+        def on_request_body_chunk: () { (Request request, String chunk) -> void } -> self
+
+        def on_request_completed: () { (Request request) -> void } -> self
+
+        def on_response_started: () { (Request request, Response response) -> void } -> self
+
+        def on_response_body_chunk: () { (Request request, Response response, String chunk) -> void } -> self
+
+        def on_response_completed: () { (Request request, response response) -> void } -> self
+
+        private
+
+        def emit_or_callback_error: (*untyped) -> void
+      end
+
+      module ConnectionMethods
+      end
+    end
+
+    type sessionCallbacks = Session & Callbacks::InstanceMethods
+  end
+end

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

@@ -0,0 +1,71 @@
+module HTTPX
+  module Plugins
+    module CircuitBreaker
+
+      class CircuitStore
+        @circuits: Hash[String, Circuit]
+
+        @circuits_mutex: Thread::Mutex
+
+        def try_open: (uri uri, response response) -> response?
+
+        def try_respond: (Request request) -> response?
+
+        def try_close: (http_uri uri) -> void
+
+        private
+
+        def get_circuit_for_uri: (uri uri) -> Circuit
+
+        def initialize: (Options & _CircuitOptions options) -> void
+      end
+
+      class Circuit
+        @state: :closed | :open | :half_open
+        @max_attempts: Integer
+        @reset_attempts_in: Float
+        @break_in: Float
+        @circuit_breaker_half_open_drip_rate: Float
+        @attempts: Integer
+        @real_attempts: Integer
+        @drip_factor: Integer
+
+        @response: response?
+        @opened_at: Float?
+        @attempted_at: Float?
+
+        def respond: () -> response?
+
+        def try_open: (response) -> response?
+
+        def try_close: () -> void
+
+        private
+
+        def initialize: (Integer max_attempts, Float reset_attempts_in, Float break_in, Float circuit_breaker_half_open_drip_rate) -> void
+      end
+
+      interface _CircuitOptions
+        def circuit_breaker_max_attempts: () -> Integer
+        def circuit_breaker_reset_attempts_in: () -> Float
+        def circuit_breaker_break_in: () -> Float
+        def circuit_breaker_half_open_drip_rate: () -> Float
+        def circuit_breaker_break_on: () -> (^(Response) -> boolish | nil)
+      end
+
+      def self.load_dependencies: (singleton(Session)) -> void
+      def self.extra_options: (Options) -> (Options & _CircuitOptions)
+
+      module InstanceMethods
+        @circuit_store: CircuitStore
+
+        private
+
+        def try_circuit_open: (Request request, response response) -> response?
+      end
+
+    end
+
+    type sessionCircuitBreaker = Session & CircuitBreaker::InstanceMethods
+  end
+end

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

@@ -0,0 +1,57 @@
+module HTTPX
+  module Plugins
+    module Compression
+
+      type deflatable = _Reader | _ToS
+
+      interface _Deflater
+        def deflate: (deflatable, ?_Writer, ?chunk_size: Integer) -> _ToS
+                   | (deflatable, ?_Writer, ?chunk_size: Integer) { (String) -> void } -> _ToS
+      end
+
+      interface _Inflater
+        def inflate: (string) -> String
+
+        def initialize: (Integer | Float bytesize) -> untyped
+      end
+
+      interface _Compressor
+        def deflater: () -> _Deflater
+        def inflater: (Integer | Float bytesize) -> _Inflater
+      end
+
+      def self.configure: (singleton(Session)) -> void
+
+      interface _CompressionOptions
+        def encodings: () -> Hash[String, _Compressor]
+      end
+
+      def self.extra_options: (Options) -> (Options & _CompressionOptions)
+
+
+      module ResponseBodyMethods
+        @encodings: Array[String]
+        @_deflaters: Array[_Deflater]
+
+        private
+
+        def decompress: (string) -> String
+      end
+
+      class Encoder
+        include Transcoder::_Encoder
+        include _ToS
+        include _Each[String]
+
+        def close: () -> void
+
+      	private
+
+        def initialize: (deflatable body, _Deflater deflater) -> untyped
+        def deflate: () -> void
+                   | () { (String) -> void } -> void
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module HTTPX
+  module Plugins
+    module ContentDigest
+      class Error < HTTPX::Error
+      end
+      class ValidationError < Error
+        attr_reader response: Response
+
+        def initialize: (String message, Response response) -> void
+      end
+      class MissingContentDigestError < ValidationError
+      end
+      class InvalidContentDigestError < ValidationError
+      end
+
+      SUPPORTED_ALGORITHMS: Hash[String, singleton(OpenSSL::Digest)]
+
+      interface _ContentDigestOptions
+        def digest_algorithm: () -> String
+        def encode_content_digest: () -> (bool | ^(Request) -> boolish)
+        def validate_content_digest: () -> (bool | ^(contentDigestResponse) -> boolish)
+      end
+
+      # def self.extra_options: (Options) -> contentDigestOptions
+
+      module InstanceMethods
+        private
+
+        def validate_content_digest: (Response response) -> void
+
+        def extract_content_digests: (String) -> Hash[String, String]
+
+        def base64digest: (Request::Body | contentDigestResponseBody body) -> String
+      end
+
+      module ResponseMethods
+        attr_reader body: contentDigestResponseBody
+      end
+
+      module ResponseBodyMethods
+        attr_reader content_digest_buffer: Response::Buffer?
+      end
+
+      type contentDigestOptions = Options & _ContentDigestOptions
+      type contentDigestResponse = Response & ResponseMethods
+      type contentDigestResponseBody = Response::Body & ResponseBodyMethods
+    end
+
+    type sessionContentDigest = Session & ContentDigest::InstanceMethods
+  end
+end

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

@@ -0,0 +1,56 @@
+module HTTPX
+  module Plugins::Cookies
+    class Cookie
+      include Comparable
+
+      MAX_LENGTH: Integer
+
+      attr_reader domain: DomainName?
+
+      attr_reader path: String
+
+      attr_reader name: String
+
+      attr_reader value: String?
+
+      attr_reader created_at: Time
+
+      @for_domain: bool
+
+      @domain_name: DomainName
+
+      def path=: (string) -> void
+
+      def domain=: (string) -> void
+
+      def expires: () -> Time?
+
+      def expired?: () -> bool
+                  | (Time) -> bool
+
+      def cookie_value: () -> String
+      alias to_s cookie_value
+
+      def match?: (String | cookie_attributes name_or_options) -> bool
+
+      def valid_for_uri?: (http_uri uri) -> bool
+
+      def self.new: (Cookie) -> instance
+                    | (cookie_attributes) -> instance
+                    | (_ToS, _ToS, ?cookie_attributes) -> instance
+
+      def self.path_match?: (String, String) -> bool
+
+      private
+
+      def initialize: (_ToS name, _ToS value, ?cookie_attributes) -> void
+
+      def acceptable_from_uri?: (uri) -> bool
+
+      module Scanner
+        RE_BAD_CHAR: Regexp
+        def self?.quote: (String s) -> String
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module HTTPX
+  module Plugins::Cookies
+    class Jar
+      type cookie = Cookie | Array[[String, String, cookie_attributes]] | Array[[String, String]] | cookie_attributes
+
+      include Enumerable[Cookie]
+
+      @cookies: Array[Cookie]
+      @mtx: Thread::Mutex
+
+      def parse: (String set_cookie) -> void
+
+      def get: (String | cookie_attributes name_or_options) -> Cookie?
+
+      def get_all: (String | cookie_attributes name_or_options) -> Array[Cookie]
+
+      def set: (_ToS | Cookie name, ?(cookie_attributes | _ToS) value_or_options) -> void
+
+      def add: (Cookie name, ?String path) -> void
+
+      def delete: (String | Cookie | cookie_attributes name_or_options) -> void
+
+      def []: (http_uri) -> Array[Cookie]
+
+      def each: (?http_uri?) { (Cookie) -> void } -> void
+              | (?http_uri?) -> Enumerable[Cookie]
+
+      def merge: (_Each[cookie] cookies) -> self
+
+      private
+
+      def initialize: (?_Each[cookie] cookies) -> untyped
+
+      def synchronize: [T] { () -> T } -> T
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module HTTPX
+  module Plugins::Cookies
+    module SetCookieParser
+      RE_WSP: Regexp
+
+      RE_NAME: Regexp
+
+      RE_BAD_CHAR: Regexp
+
+      RE_COOKIE_COMMA: Regexp
+
+      def self?.call: (String set_cookie) { (String name, String value, cookie_attributes attrs) -> void } -> void
+
+      def self?.scan_dquoted: (StringScanner scanner) -> String
+
+      def self?.scan_value: (StringScanner scanner, ?bool comma_as_separator) -> String
+
+      def self?.scan_name_value: (StringScanner scanner, ?bool comma_as_separator) -> [String?, String?]
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module HTTPX
+  module Plugins
+    module Cookies
+      type cookie_attributes = Hash[Symbol | String, top]
+
+      type jar = Jar | _Each[Jar::cookie]
+
+      interface _CookieOptions
+        def cookies: () -> Jar?
+
+        def merge_cookie_in_jar: (Array[String] cookies, Jar jar) -> void
+      end
+
+      def self.extra_options: (Options) -> (Options & _CookieOptions)
+
+      module InstanceMethods
+        def cookies: () -> Jar
+
+        def make_jar: (*untyped) -> Jar
+      end
+
+      module HeadersMethods
+        def set_cookie: (Array[Cookie]) -> void
+      end
+    end
+
+    type sessionCookies = Session & Cookies::InstanceMethods
+    type headersCookies = Headers & Cookies::HeadersMethods
+  end
+end

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

@@ -0,0 +1,19 @@
+module HTTPX
+  module Plugins
+    module DigestAuth
+      interface _DigestOptions
+        def digest: () -> Authentication::Digest?
+      end
+
+      def self.extra_options: (Options) -> (Options & _DigestOptions)
+
+      def self.load_dependencies: (singleton(Session) klass) -> void
+
+      module InstanceMethods
+        def digest_auth: (string user, string password, ?hashed: bool) -> instance
+      end
+    end
+
+    type sessionDigestAuth = sessionAuth & DigestAuth::InstanceMethods
+  end
+end

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

@@ -0,0 +1,34 @@
+module HTTPX
+  module Plugins
+    module Expect
+      EXPECT_TIMEOUT: Integer
+      NOEXPECT_STORE_MUTEX: Thread::Mutex
+
+      self.@no_expect_store: Store
+      def self.no_expect_store: () -> Store
+
+      def self.extra_options: (Options) -> (Options & _ExpectOptions)
+
+      class Store
+        @store: Array[String]
+        @mutex: Thread::Mutex
+
+        def include?: (String host) -> bool
+
+        def add: (String host) -> void
+
+        def delete: (String host) -> void
+      end
+
+      module RequestMethods
+        @informational_status: Integer?
+      end
+
+      interface _ExpectOptions
+        def expect_timeout: () -> Integer?
+
+        def expect_threshold_size: () -> Integer?
+      end
+    end
+  end
+end