onebusaway-sdk 0.1.0.pre.alpha.206 → 0.1.0.pre.alpha.207

data/rbi/lib/onebusaway-sdk/util.rbi

@@ -1,85 +1,121 @@
 # typed: strong
 
 module OnebusawaySDK
+  # @api private
   module Util
+    # @api private
     sig { returns(Float) }
     def self.monotonic_secs
     end
 
-    sig { returns(String) }
-    def self.arch
-    end
+    class << self
+      # @api private
+      sig { returns(String) }
+      def arch
+      end
 
-    sig { returns(String) }
-    def self.os
+      # @api private
+      sig { returns(String) }
+      def os
+      end
     end
 
-    sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
-    def self.primitive?(input)
-    end
+    class << self
+      # @api private
+      sig { params(input: T.anything).returns(T::Boolean) }
+      def primitive?(input)
+      end
 
-    sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
-    def self.coerce_boolean(input)
-    end
+      # @api private
+      sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
+      def coerce_boolean(input)
+      end
 
-    sig { params(input: T.anything).returns(T.nilable(T::Boolean)) }
-    def self.coerce_boolean!(input)
-    end
+      # @api private
+      sig { params(input: T.anything).returns(T.nilable(T::Boolean)) }
+      def coerce_boolean!(input)
+      end
 
-    sig { params(input: T.anything).returns(T.any(Integer, T.anything)) }
-    def self.coerce_integer(input)
-    end
+      # @api private
+      sig { params(input: T.anything).returns(T.any(Integer, T.anything)) }
+      def coerce_integer(input)
+      end
 
-    sig { params(input: T.anything).returns(T.any(Float, T.anything)) }
-    def self.coerce_float(input)
-    end
+      # @api private
+      sig { params(input: T.anything).returns(T.any(Float, T.anything)) }
+      def coerce_float(input)
+      end
 
-    sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) }
-    def self.coerce_hash(input)
+      # @api private
+      sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) }
+      def coerce_hash(input)
+      end
     end
 
     OMIT = T.let(T.anything, T.anything)
 
-    sig { params(lhs: T.anything, rhs: T.anything, concat: T::Boolean).returns(T.anything) }
-    private_class_method def self.deep_merge_lr(lhs, rhs, concat: false)
-    end
-
-    sig do
-      params(values: T::Array[T.anything], sentinel: T.nilable(T.anything), concat: T::Boolean)
-        .returns(T.anything)
-    end
-    def self.deep_merge(*values, sentinel: nil, concat: false)
-    end
+    class << self
+      # @api private
+      sig { params(lhs: T.anything, rhs: T.anything, concat: T::Boolean).returns(T.anything) }
+      private def deep_merge_lr(lhs, rhs, concat: false)
+      end
 
-    sig do
-      params(
-        data: T.any(T::Hash[Symbol, T.anything], T::Array[T.anything], T.anything),
-        pick: T.nilable(T.any(Symbol, Integer, T::Array[T.any(Symbol, Integer)])),
-        sentinel: T.nilable(T.anything),
-        blk: T.nilable(T.proc.returns(T.anything))
+      # @api private
+      #
+      # Recursively merge one hash with another. If the values at a given key are not
+      #   both hashes, just take the new value.
+      sig do
+        params(values: T::Array[T.anything], sentinel: T.nilable(T.anything), concat: T::Boolean)
+          .returns(T.anything)
+      end
+      def deep_merge(
+        *values,
+        # the value to return if no values are provided.
+        sentinel: nil,
+        # whether to merge sequences by concatenation.
+        concat: false
       )
-        .returns(T.nilable(T.anything))
-    end
-    def self.dig(data, pick, sentinel = nil, &blk)
-    end
+      end
 
-    sig { params(uri: URI::Generic).returns(String) }
-    def self.uri_origin(uri)
+      # @api private
+      sig do
+        params(
+          data: T.any(T::Hash[Symbol, T.anything], T::Array[T.anything], T.anything),
+          pick: T.nilable(T.any(Symbol, Integer, T::Array[T.any(Symbol, Integer)])),
+          sentinel: T.nilable(T.anything),
+          blk: T.nilable(T.proc.returns(T.anything))
+        )
+          .returns(T.nilable(T.anything))
+      end
+      def dig(data, pick, sentinel = nil, &blk)
+      end
     end
 
-    sig { params(path: T.any(String, T::Array[String])).returns(String) }
-    def self.interpolate_path(path)
-    end
+    class << self
+      # @api private
+      sig { params(uri: URI::Generic).returns(String) }
+      def uri_origin(uri)
+      end
 
-    sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) }
-    def self.decode_query(query)
+      # @api private
+      sig { params(path: T.any(String, T::Array[String])).returns(String) }
+      def interpolate_path(path)
+      end
     end
 
-    sig do
-      params(query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
-        .returns(T.nilable(String))
-    end
-    def self.encode_query(query)
+    class << self
+      # @api private
+      sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) }
+      def decode_query(query)
+      end
+
+      # @api private
+      sig do
+        params(query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
+          .returns(T.nilable(String))
+      end
+      def encode_query(query)
+      end
     end
 
     ParsedUriShape = T.type_alias do
@@ -92,77 +128,143 @@ module OnebusawaySDK
       }
     end
 
-    sig { params(url: T.any(URI::Generic, String)).returns(OnebusawaySDK::Util::ParsedUriShape) }
-    def self.parse_uri(url)
-    end
+    class << self
+      # @api private
+      sig { params(url: T.any(URI::Generic, String)).returns(OnebusawaySDK::Util::ParsedUriShape) }
+      def parse_uri(url)
+      end
 
-    sig { params(parsed: OnebusawaySDK::Util::ParsedUriShape).returns(URI::Generic) }
-    def self.unparse_uri(parsed)
-    end
+      # @api private
+      sig { params(parsed: OnebusawaySDK::Util::ParsedUriShape).returns(URI::Generic) }
+      def unparse_uri(parsed)
+      end
 
-    sig do
-      params(lhs: OnebusawaySDK::Util::ParsedUriShape, rhs: OnebusawaySDK::Util::ParsedUriShape)
-        .returns(URI::Generic)
-    end
-    def self.join_parsed_uri(lhs, rhs)
+      # @api private
+      sig do
+        params(lhs: OnebusawaySDK::Util::ParsedUriShape, rhs: OnebusawaySDK::Util::ParsedUriShape)
+          .returns(URI::Generic)
+      end
+      def join_parsed_uri(lhs, rhs)
+      end
     end
 
-    sig do
-      params(
-        headers: T::Hash[String,
-                         T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))]
-      )
-        .returns(T::Hash[String, String])
-    end
-    def self.normalized_headers(*headers)
+    class << self
+      # @api private
+      sig do
+        params(
+          headers: T::Hash[String,
+                           T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))]
+        )
+          .returns(T::Hash[String, String])
+      end
+      def normalized_headers(*headers)
+      end
     end
 
-    sig { params(io: StringIO, boundary: String, key: T.any(Symbol, String), val: T.anything).void }
-    private_class_method def self.encode_multipart_formdata(io, boundary:, key:, val:)
-    end
+    # @api private
+    #
+    # An adapter that satisfies the IO interface required by `::IO.copy_stream`
+    class ReadIOAdapter
+      # @api private
+      sig { params(max_len: T.nilable(Integer)).returns(String) }
+      private def read_enum(max_len)
+      end
 
-    sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) }
-    def self.encode_content(headers, body)
-    end
+      # @api private
+      sig { params(max_len: T.nilable(Integer), out_string: T.nilable(String)).returns(T.nilable(String)) }
+      def read(max_len = nil, out_string = nil)
+      end
 
-    sig do
-      params(
-        headers: T.any(T::Hash[String, String], Net::HTTPHeader),
-        stream: T::Enumerable[String],
-        suppress_error: T::Boolean
-      )
-        .returns(T.anything)
-    end
-    def self.decode_content(headers, stream:, suppress_error: false)
+      # @api private
+      sig do
+        params(
+          stream: T.any(String, IO, StringIO, T::Enumerable[String]),
+          blk: T.proc.params(arg0: String).void
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(stream, &blk)
+      end
     end
 
-    sig { params(enum: T::Enumerable[T.anything], close: T.proc.void).returns(T::Enumerable[T.anything]) }
-    def self.fused_enum(enum, &close)
+    class << self
+      sig { params(blk: T.proc.params(y: Enumerator::Yielder).void).returns(T::Enumerable[String]) }
+      def string_io(&blk)
+      end
     end
 
-    sig { params(enum: T.nilable(T::Enumerable[T.anything])).void }
-    def self.close_fused!(enum)
-    end
+    class << self
+      # @api private
+      sig do
+        params(y: Enumerator::Yielder, boundary: String, key: T.any(Symbol, String), val: T.anything).void
+      end
+      private def encode_multipart_formdata(y, boundary:, key:, val:)
+      end
+
+      # @api private
+      sig { params(body: T.anything).returns([String, T::Enumerable[String]]) }
+      private def encode_multipart_streaming(body)
+      end
 
-    sig do
-      params(
-        enum: T.nilable(T::Enumerable[T.anything]),
-        blk: T.proc.params(arg0: Enumerator::Yielder).void
-      ).void
+      # @api private
+      sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) }
+      def encode_content(headers, body)
+      end
+
+      # @api private
+      sig do
+        params(
+          headers: T.any(T::Hash[String, String], Net::HTTPHeader),
+          stream: T::Enumerable[String],
+          suppress_error: T::Boolean
+        )
+          .returns(T.anything)
+      end
+      def decode_content(headers, stream:, suppress_error: false)
+      end
     end
-    def self.chain_fused(enum, &blk)
+
+    class << self
+      # @api private
+      #
+      # https://doc.rust-lang.org/std/iter/trait.FusedIterator.html
+      sig do
+        params(enum: T::Enumerable[T.anything], external: T::Boolean, close: T.proc.void)
+          .returns(T::Enumerable[T.anything])
+      end
+      def fused_enum(enum, external: false, &close)
+      end
+
+      # @api private
+      sig { params(enum: T.nilable(T::Enumerable[T.anything])).void }
+      def close_fused!(enum)
+      end
+
+      # @api private
+      sig do
+        params(enum: T.nilable(T::Enumerable[T.anything]), blk: T.proc.params(arg0: Enumerator::Yielder).void)
+          .returns(T::Enumerable[T.anything])
+      end
+      def chain_fused(enum, &blk)
+      end
     end
 
-    SSEMessage = T.type_alias do
+    ServerSentEvent = T.type_alias do
       {event: T.nilable(String), data: T.nilable(String), id: T.nilable(String), retry: T.nilable(Integer)}
     end
 
-    sig { params(enum: T::Enumerable[String]).returns(T::Enumerable[String]) }
-    def self.enum_lines(enum)
-    end
+    class << self
+      # @api private
+      sig { params(enum: T::Enumerable[String]).returns(T::Enumerable[String]) }
+      def decode_lines(enum)
+      end
 
-    sig { params(lines: T::Enumerable[String]).returns(OnebusawaySDK::Util::SSEMessage) }
-    def self.parse_sse(lines)
+      # @api private
+      #
+      # https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
+      sig { params(lines: T::Enumerable[String]).returns(OnebusawaySDK::Util::ServerSentEvent) }
+      def decode_sse(lines)
+      end
     end
   end
 end

data/rbi/lib/onebusaway-sdk/version.rbi

@@ -1,5 +1,5 @@
 # typed: strong
 
 module OnebusawaySDK
-  VERSION = "0.1.0-alpha.206"
+  VERSION = "0.1.0-alpha.207"
 end

data/sig/onebusaway-sdk/base_client.rbs

@@ -45,7 +45,12 @@ module OnebusawaySDK
       response_headers: ::Hash[String, String]
     ) -> OnebusawaySDK::BaseClient::request_input
 
-    # @private
+    def self.reap_connection!: (
+      Integer | OnebusawaySDK::APIConnectionError status,
+      stream: Enumerable[String]?
+    ) -> void
+
+    # @api private
     attr_accessor requester: top
 
     def initialize: (

data/sig/onebusaway-sdk/base_model.rbs

@@ -85,9 +85,11 @@ module OnebusawaySDK
   class Union
     extend OnebusawaySDK::Converter
 
-    private def self.known_variants: -> ::Array[[Symbol?, Proc]]
+    private def self.known_variants: -> ::Array[[Symbol?, (^-> OnebusawaySDK::Converter::input)]]
 
-    def self.variants: -> ::Array[[Symbol?, top]]
+    def self.derefed_variants: -> ::Array[[Symbol?, top]]
+
+    def self.variants: -> ::Array[top]
 
     private def self.discriminator: (Symbol property) -> void
 
@@ -118,7 +120,7 @@ module OnebusawaySDK
     ) -> ([true, top, nil] | [false, bool, Integer])
   end
 
-  class ArrayOf
+  class ArrayOf[Elem]
     include OnebusawaySDK::Converter
 
     def ===: (top other) -> bool
@@ -133,7 +135,7 @@ module OnebusawaySDK
       top value
     ) -> ([true, top, nil] | [false, bool, Integer])
 
-    def item_type: -> OnebusawaySDK::Converter::input
+    def item_type: -> Elem
 
     def initialize: (
       ::Hash[Symbol, top]
@@ -143,7 +145,7 @@ module OnebusawaySDK
     ) -> void
   end
 
-  class HashOf
+  class HashOf[Elem]
     include OnebusawaySDK::Converter
 
     def ===: (top other) -> bool
@@ -158,7 +160,7 @@ module OnebusawaySDK
       top value
     ) -> ([true, top, nil] | [false, bool, Integer])
 
-    def item_type: -> OnebusawaySDK::Converter::input
+    def item_type: -> Elem
 
     def initialize: (
       ::Hash[Symbol, top]

data/sig/onebusaway-sdk/base_page.rbs

@@ -14,7 +14,7 @@ module OnebusawaySDK
       client: OnebusawaySDK::BaseClient,
       req: OnebusawaySDK::BaseClient::request_components,
       headers: ::Hash[String, String],
-      unwrapped: top
+      page_data: top
     ) -> void
   end
 end

data/sig/onebusaway-sdk/errors.rbs

@@ -1,17 +1,17 @@
 module OnebusawaySDK
   class Error < StandardError
-    attr_reader cause: StandardError?
+    attr_accessor cause: StandardError?
   end
 
   class ConversionError < OnebusawaySDK::Error
   end
 
   class APIError < OnebusawaySDK::Error
-    attr_reader url: URI::Generic
+    attr_accessor url: URI::Generic
 
-    attr_reader status: Integer?
+    attr_accessor status: Integer?
 
-    attr_reader body: top?
+    attr_accessor body: top?
 
     def initialize: (
       url: URI::Generic,

data/sig/onebusaway-sdk/pooled_net_requester.rbs

@@ -15,14 +15,21 @@ module OnebusawaySDK
 
     def self.build_request: (
       OnebusawaySDK::PooledNetRequester::request request
-    ) -> top
+    ) {
+      (String arg0) -> void
+    } -> top
 
-    private def with_pool: (URI::Generic url) { (top arg0) -> void } -> void
+    private def with_pool: (
+      URI::Generic url,
+      deadline: Float
+    ) {
+      (top arg0) -> void
+    } -> void
 
     def execute: (
       OnebusawaySDK::PooledNetRequester::request request
-    ) -> [top, Enumerable[String]]
+    ) -> [Integer, top, Enumerable[String]]
 
-    def initialize: -> void
+    def initialize: (size: Integer) -> void
   end
 end

data/sig/onebusaway-sdk/request_options.rbs

@@ -38,5 +38,9 @@ module OnebusawaySDK
     attr_accessor max_retries: Integer?
 
     attr_accessor timeout: Float?
+
+    def initialize: (
+      ?OnebusawaySDK::request_options | ::Hash[Symbol, top] values
+    ) -> void
   end
 end

data/sig/onebusaway-sdk/util.rbs

@@ -6,7 +6,7 @@ module OnebusawaySDK
 
     def self?.os: -> String
 
-    def self?.primitive?: (top input) -> (bool | top)
+    def self?.primitive?: (top input) -> bool
 
     def self?.coerce_boolean: (top input) -> (bool | top)
 
@@ -74,13 +74,33 @@ module OnebusawaySDK
       | ::Array[(String | Integer)?])?] headers
     ) -> ::Hash[String, String]
 
+    class ReadIOAdapter
+      private def read_enum: (Integer? max_len) -> String
+
+      def read: (?Integer? max_len, ?String? out_string) -> String?
+
+      def initialize: (
+        String | IO | StringIO | Enumerable[String] stream
+      ) {
+        (String arg0) -> void
+      } -> void
+    end
+
+    def self?.string_io: {
+      (Enumerator::Yielder y) -> void
+    } -> Enumerable[String]
+
     def self?.encode_multipart_formdata: (
-      StringIO io,
+      Enumerator::Yielder y,
       boundary: String,
       key: Symbol | String,
       val: top
     ) -> void
 
+    def self?.encode_multipart_streaming: (
+      top body
+    ) -> [String, Enumerable[String]]
+
     def self?.encode_content: (::Hash[String, String] headers, top body) -> top
 
     def self?.decode_content: (
@@ -89,7 +109,12 @@ module OnebusawaySDK
       suppress_error: bool
     ) -> top
 
-    def self?.fused_enum: (Enumerable[top] enum) { -> void } -> Enumerable[top]
+    def self?.fused_enum: (
+      Enumerable[top] enum,
+      external: bool
+    ) {
+      -> void
+    } -> Enumerable[top]
 
     def self?.close_fused!: (Enumerable[top]? enum) -> void
 
@@ -97,15 +122,15 @@ module OnebusawaySDK
       Enumerable[top]? enum
     ) {
       (Enumerator::Yielder arg0) -> void
-    } -> void
+    } -> Enumerable[top]
 
-    type sse_message =
+    type server_sent_event =
       { event: String?, data: String?, id: String?, retry: Integer? }
 
-    def self?.enum_lines: (Enumerable[String] enum) -> Enumerable[String]
+    def self?.decode_lines: (Enumerable[String] enum) -> Enumerable[String]
 
-    def self?.parse_sse: (
+    def self?.decode_sse: (
       Enumerable[String] lines
-    ) -> OnebusawaySDK::Util::sse_message
+    ) -> OnebusawaySDK::Util::server_sent_event
   end
 end

data/sig/onebusaway-sdk/version.rbs

@@ -1,3 +1,3 @@
 module OnebusawaySDK
-  VERSION: "0.1.0-alpha.205"
+  VERSION: "0.1.0-alpha.206"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: onebusaway-sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.alpha.206
+  version: 0.1.0.pre.alpha.207
 platform: ruby
 authors:
 - Onebusaway SDK
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-06 00:00:00.000000000 Z
+date: 2025-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -322,10 +322,10 @@ files:
 - sig/onebusaway-sdk/resources/vehicles_for_agency.rbs
 - sig/onebusaway-sdk/util.rbs
 - sig/onebusaway-sdk/version.rbs
-homepage: https://gemdocs.org/gems/onebusaway-sdk/latest
+homepage: https://gemdocs.org/gems/onebusaway-sdk
 licenses: []
 metadata:
-  homepage_uri: https://gemdocs.org/gems/onebusaway-sdk/latest
+  homepage_uri: https://gemdocs.org/gems/onebusaway-sdk
   source_code_uri: https://github.com/OneBusAway/ruby-sdk
   rubygems_mfa_required: 'false'
 post_install_message: