raioquic 0.1.0

data/sig/raioquic/quic/event.rbs

@@ -0,0 +1,51 @@
+module Raioquic
+  module Quic
+    module Event
+      class QuicEvent
+      end
+
+      class ConnectionIdIssued < QuicEvent
+        attr_accessor connection_id: ::String
+      end
+
+      class ConnectionIdRetired < QuicEvent
+        attr_accessor connection_id: ::String
+      end
+
+      class ConnectionTerminated < QuicEvent
+        attr_accessor error_code: ::Integer
+        attr_accessor frame_type: ::Integer | nil
+        attr_accessor reason_phrase: ::String
+      end
+
+      class DatagramFrameReceived < QuicEvent
+        attr_accessor data: ::String
+      end
+
+      class HandshakeCompleted < QuicEvent
+        attr_accessor alpn_protocol: ::String | nil
+        attr_accessor early_data_accepted: bool
+        attr_accessor session_resumed: bool
+      end
+
+      class PingAcknowledged < QuicEvent
+        attr_accessor uid: ::Integer
+      end
+
+      class ProtocolNegotiated < QuicEvent
+        attr_accessor alpn_protocol: ::String | nil
+      end
+
+      class StreamDataReceived < QuicEvent
+        attr_accessor data: ::String
+        attr_accessor end_stream: bool
+        attr_accessor stream_id: ::Integer
+      end
+
+      class StreamReset < QuicEvent
+        attr_accessor error_code: ::Integer
+        attr_accessor stream_id: ::Integer
+      end
+    end
+  end
+end

data/sig/raioquic/quic/logger.rbs

@@ -0,0 +1,57 @@
+module Raioquic
+  module Quic
+    module Logger
+      QLOG_VERSION: ::String
+
+      class QuicLoggerTrace
+        PACKET_TYPE_NAMES: ::Hash[::Integer, ::String]
+        @odcid: ::String
+        @events: ::Array[untyped]
+        @vantage_point: { name: ::String, type: ("client"|"server")}
+
+        def initialize: (is_client: bool, odcid: ::String) -> void
+        def encode_ack_frame: (ranges: ::Raioquic::Quic::Rangeset, delay: ::Float) -> { ack_delay: ::Float, acked_ranges: ::Array[untyped], frame_type: "ack" }
+        # type connection_close_frame_attrs = { error_code: ::Integer, error_space: ("application"|"transport"), frame_type: "connection_close", raw_error_code: ::Integer, reason: ::String }
+        def encode_connection_close_frame: (error_code: ::Integer, ?frame_type: (::Integer | nil), reason_phrase: ::String) -> ::Hash[::Symbol, (::String|::Integer)]
+                                        #  (connection_close_frame_attrs | (connection_close_frame_attrs & { triggerr_frame_type: ("unidirectional"|"bidirectional")}))
+          # { error_code: ::Integer, error_space: ("application"|"transport"), frame_type: "connection_close", raw_error_code: ::Integer, reason: ::String, triggerr_frame_type: ::Integer }
+        def encode_connection_limit_frame: (frame_type: ::Integer, maximum: ::Integer) -> ({ frame_type: "max_data", maximum: ::Integer } | { frame_type: "max_streams", maximum: ::Integer, stream_type: ("unidirectional"|"bidirectional") })
+        def encode_crypto_frame: (frame: ::Raioquic::Quic::Packet::QuicStreamFrame) -> { frame_type: "crypto", length: ::Integer, offset: ::Integer }
+        def encode_data_blocked_frame: (limit: ::Integer) -> { frame_type: "data_blocked", limit: ::Integer }
+        def encode_datagram_frame: (length: ::Integer) -> { frame_type: "datagram", length: ::Integer }
+        def encode_handshake_done_frame: () -> { frame_type: "handshake_done" }
+        def encode_max_stream_data_frame: (maximum: ::Integer, stream_id: ::String) -> { frame_type: "max_stream_data", maximum: ::Integer, stream_id: ::String }
+        def encode_new_connection_id_frame: (connection_id: ::String, retire_prior_to: ::Integer, sequence_number: ::Integer, stateless_reset_token: ::String) ->
+                                          { connection_id: ::String, frame_type: "new_connection_id", length: ::Integer, reset_token: ::String, retire_prior_to: ::Integer, sequence_number: ::Integer }
+        def encode_new_token_frame: (token: ::String) -> { frame_type: "new_token", length: ::Integer, token: ::String }
+        def encode_padding_frame: () -> { frame_type: "padding" }
+        def encode_path_challenge_frame: (data: ::String) -> { frame_type: "path_challenge", data: ::String }
+        def encode_path_response_frame: (data: ::String) -> { frame_type: "path_response", data: ::String }
+        def encode_ping_frame: () -> { frame_type: "ping" }
+        def encode_reset_stream_frame: (error_code: ::Integer, final_size: ::Integer, stream_id: ::String) -> { error_code: ::Integer, final_size: ::Integer, frame_type: "reset_stream", stream_id: ::String }
+        def encode_retire_connection_id_frame: (sequence_number: ::Integer) -> { frame_type: "retire_connection_id", sequence_number: ::Integer }
+        def encode_stream_data_blocked_frame: (limit: ::Integer, stream_id: ::String) -> { frame_type: "stream_data_blocked", limit: ::Integer, stream_id: ::String }
+        def encode_stop_sending_frame: (error_code: ::Integer, stream_id: ::String) -> { frame_type: "stop_sending", error_code: ::Integer, stream_id: ::String }
+        def encode_stream_frame: (frame: ::Raioquic::Quic::Packet::QuicStreamFrame, stream_id: ::String) -> { fin: bool, frame_type: "stream", length: ::Integer, offset: ::Integer, stream_id: ::String }
+        def encode_streams_blocked_frame: (is_unidirectional: bool, limit: ::Integer) -> { frame_type: "streams_blocked", limit: ::Integer, stream_type: ("unidirectional"|"bidirectional") }
+        def encode_time: (::Float seconds) -> ::Float
+        def encode_transport_parameters: (owner: ::String, parameters: ::Raioquic::Quic::Packet::QuicTransportParameters) -> ::Hash[::Symbol, (::String|::Integer)]
+        def packet_type: (::Integer packet_type) -> ::String
+        def log_event: (category: ::String, event: ::String, data: ::Hash[::Symbol, untyped]) -> void
+        def to_dict: () -> ::Hash[::Symbol, untyped]
+      end
+
+      class QuicLogger
+        def initialize: () -> void
+        def start_trace: (is_client: bool, odcid: ::String) -> QuicLoggerTrace
+        def to_dict: () -> { qlog_format: ::String, qlog_version: ::String, traces: ::Array[untyped] }
+        def end_trace: (QuicLoggerTrace trace) -> void
+      end
+
+      class QuicFileLogger < QuicLogger
+        def initialize: (path: ::String) -> void
+        # def end_trace: (QuicLoggerTrace trace) -> void
+      end
+    end
+  end
+end

data/sig/raioquic/quic/packet.rbs

@@ -0,0 +1,157 @@
+module Raioquic
+  module Quic
+    class Packet
+      PACKET_LONG_HEADER: ::Integer
+      PACKET_FIXED_BIT: ::Integer
+      PACKET_SPIN_BIT: ::Integer
+      PACKET_TYPE_INITIAL: ::Integer
+      PACKET_TYPE_ZERO_RTT: ::Integer
+      PACKET_TYPE_HANDSHAKE: ::Integer
+      PACKET_TYPE_RETRY: ::Integer
+      PACKET_TYPE_ONE_RTT: ::Integer
+      PACKET_TYPE_MASK: ::Integer
+      CONNECTION_ID_MAX_SIZE: ::Integer
+      PACKET_NUMBER_MAX_SIZE: ::Integer
+      RETRY_AEAD_KEY_VERSION_1: ::String
+      RETRY_AEAD_NONCE_VERSION_1: ::String
+      RETRY_INTEGRITY_TAG_SIZE: ::Integer
+      STATELESS_RESET_TOKEN_SIZE: ::Integer
+
+      class QuicErrorCode
+        NO_ERROR: ::Integer
+        INTERNAL_ERROR: ::Integer
+        CONNECTION_REFUSED: ::Integer
+        FLOW_CONTROL_ERROR: ::Integer
+        STREAM_LIMIT_ERROR: ::Integer
+        STREAM_STATE_ERROR: ::Integer
+        FINAL_SIZE_ERROR: ::Integer
+        FRAME_ENCODING_ERROR: ::Integer
+        TRANSPORT_PARAMETER_ERROR: ::Integer
+        CONNECTION_ID_LIMIT_ERROR: ::Integer
+        PROTOCOL_VIOLATION: ::Integer
+        INVALID_TOKEN: ::Integer
+        APPLICATION_ERROR: ::Integer
+        CRYPTO_BUFFER_EXCEEDED: ::Integer
+        KEY_UPDATE_ERROR: ::Integer
+        AEAD_LIMIT_REACHED: ::Integer
+        CRYPTO_ERROR: ::Integer
+      end
+
+      class QuicProtocolVersion
+        NEGOTIATION: ::Integer
+        VERSION_1: ::Integer
+      end
+
+      class QuicHeader
+        attr_accessor is_long_header: bool
+        attr_accessor version: Integer?
+        attr_accessor packet_type: Integer
+        attr_accessor destination_cid: String
+        attr_accessor source_cid: String
+        attr_accessor token: String
+        attr_accessor integrity_tag: String
+        attr_accessor rest_length: Integer
+      end
+
+      def self.decode_packet_number: (truncated: Integer, num_bits: Integer, expected: Integer) -> Integer
+      def self.get_retry_integrity_tag: (packet_without_tag: String, original_destination_cid: String) -> String
+      def self.get_spin_bit: (::Integer) -> bool
+      def self.is_draft_version: (::Integer) -> FalseClass
+      def self.is_long_header: (::Integer) -> bool
+      def self.pull_quic_header: (buf: ::Raioquic::Buffer, host_cid_length: ::Integer) -> QuicHeader
+      def self.encode_quic_retry: (version: untyped, source_cid: ::String, destination_cid: ::String, original_destination_cid: ::String, retry_token: ::String:writing) -> ::String
+      def self.encode_quic_version_negotiation: (source_cid: ::String, destination_cid: ::String, supported_versions: ::Array[untyped]) -> ::String
+
+      private def self.get_urandom_byte: -> ::Integer
+
+      class QuicPreferredAddress
+        attr_accessor ipv4_address: ::Hash[::Symbol, untyped]?
+        attr_accessor ipv6_address: ::Hash[::Symbol, untyped]?
+        attr_accessor connection_id: ::String
+        attr_accessor stateless_reset_token: ::String
+      end
+
+      class QuicTransportParameters
+        attr_accessor original_destination_connection_id: ::String?
+        attr_accessor max_idle_timeout: ::Integer?
+        attr_accessor stateless_reset_token: ::String?
+        attr_accessor max_udp_payload_size: ::Integer?
+        attr_accessor initial_max_data: ::Integer?
+        attr_accessor initial_max_stream_data_bidi_local: ::Integer?
+        attr_accessor initial_max_stream_data_bidi_remote: ::Integer?
+        attr_accessor initial_max_stream_data_uni: ::Integer?
+        attr_accessor initial_max_streams_bidi: ::Integer?
+        attr_accessor initial_max_streams_uni: ::Integer?
+        attr_accessor ack_delay_exponent: ::Integer?
+        attr_accessor max_ack_delay: ::Integer?
+        attr_accessor disable_active_migration: bool?
+        attr_accessor preferred_address: QuicPreferredAddress?
+        attr_accessor active_connection_id_limit: ::Integer?
+        attr_accessor initial_source_connection_id: ::String?
+        attr_accessor retry_source_connection_id: ::String?
+        attr_accessor max_datagram_frame_size: ::Integer?
+        attr_accessor quantum_readiness: ::String?
+      end
+
+      PARAMS: ::Hash[::Integer, ::Hash[::Symbol, ::Symbol]]
+
+      def self.pull_quic_preferred_address: (::Raioquic::Buffer buf) -> untyped
+      def self.push_quic_preferred_address: (buf: ::Raioquic::Buffer, preferred_address: QuicPreferredAddress) -> void
+      def self.pull_quic_transport_parameters: (::Raioquic::Buffer buf) -> QuicTransportParameters
+      def self.push_quic_transport_parameters: (buf: ::Raioquic::Buffer, params: QuicTransportParameters) -> void
+
+      class QuicFrameType
+        PADDING: ::Integer
+        PING: ::Integer
+        ACK: ::Integer
+        ACK_ECN: ::Integer
+        RESET_STREAM: ::Integer
+        STOP_SENDING: ::Integer
+        CRYPTO: ::Integer
+        NEW_TOKEN: ::Integer
+        STREAM_BASE: ::Integer
+        MAX_DATA: ::Integer
+        MAX_STREAM_DATA: ::Integer
+        MAX_STREAMS_BIDI: ::Integer
+        MAX_STREAMS_UNI: ::Integer
+        DATA_BLOCKED: ::Integer
+        STREAM_DATA_BLOCKED: ::Integer
+        STREAMS_BLOCKED_BIDI: ::Integer
+        STREAMS_BLOCKED_UNI: ::Integer
+        NEW_CONNECTION_ID: ::Integer
+        RETIRE_CONNECTION_ID: ::Integer
+        PATH_CHALLENGE: ::Integer
+        PATH_RESPONSE: ::Integer
+        TRANSPORT_CLOSE: ::Integer
+        APPLICATION_CLOSE: ::Integer
+        HANDSHAKE_DONE: ::Integer
+        DATAGRAM: ::Integer
+        DATAGRAM_WITH_LENGTH: ::Integer
+      end
+
+      NON_ACK_ELICITING_FRAME_TYPES: ::Array[::Integer]
+      NON_IN_FLIGHT_FRAME_TYPES: ::Array[::Integer]
+      PROBING_FRAME_TYPES: ::Array[::Integer]
+
+      class QuicResetStreamFrame
+        attr_accessor error_code: ::Integer
+        attr_accessor final_size: ::Integer
+        attr_accessor stream_id: ::Integer
+      end
+
+      class QuicStopSendingFrame
+        attr_accessor error_code: ::Integer
+        attr_accessor stream_id: ::Integer
+      end
+
+      class QuicStreamFrame
+        attr_accessor data: ::String
+        attr_accessor fin: bool
+        attr_accessor offset: ::Integer
+      end
+
+      def self.pull_ack_frame: (::Raioquic::Buffer) -> untyped
+      def self.push_ack_frame: (buf: ::Raioquic::Buffer, rangeset: Rangeset, delay: ::Integer) -> ::Integer
+    end
+  end
+end

data/sig/raioquic/quic/packet_builder.rbs

@@ -0,0 +1,76 @@
+module Raioquic
+  module Quic
+    class PacketBuilder
+      PACKET_MAX_SIZE: 1280
+      PACKET_LENGTH_SEND_SIZE: 2
+      PACKET_NUMBER_SEND_SIZE: 2
+
+      class QuicDeliveryState
+        ACKED: 0
+        LOST: 1
+        EXPIRED: 2
+      end
+
+      class QuicSentPacket
+        attr_accessor epoch: ::Integer
+        attr_accessor in_flight: bool
+        attr_accessor is_ack_eliciting: bool
+        attr_accessor is_crypto_packet: bool
+        attr_accessor packet_number: ::Integer
+        attr_accessor packet_type: ::Integer
+        attr_accessor sent_time: ::Integer
+        attr_accessor sent_bytes: ::Integer
+        attr_accessor delivery_handlers: ::Array[[^() -> void, untyped]]
+        attr_accessor quic_logger_frames: untyped
+      end
+
+      class QuicPacketBuilderStop < StandardError
+      end
+
+      class QuicPacketBuilder
+        attr_reader packet_number: ::Integer
+        attr_reader quic_logger_frames: ::Array[untyped] | nil
+        attr_accessor max_flight_bytes: ::Integer | nil
+        attr_accessor max_total_bytes: ::Integer | nil
+
+        @packet: QuicSentPacket | nil
+        @max_flight_bytes: ::Integer | nil
+        @max_total_bytes: ::Integer | nil
+        @quic_logger_frames: ::Array[untyped] | nil
+        @host_cid: ::String
+        @peer_cid: ::String
+        @is_client: bool
+        @peer_token: ::String
+        @quic_logger: ::Raioquic::Quic::Logger::QuicLoggerTrace
+        @spin_bit: bool
+        @version: ::Integer
+        @datagrams: ::Array[::String]
+        @datagram_flight_bytes: ::Integer
+        @datagram_init: bool
+        @packets: ::Array[QuicSentPacket]
+        @flight_bytes: ::Integer
+        @total_bytes: ::Integer
+        @header_size: ::Integer
+        @packet: untyped
+        @packet_crypto: untyped
+        @packet_long_header: bool
+        @packet_number: ::Integer
+        @packet_start: ::Integer
+        @packet_type: ::Integer
+        @buffer: Buffer
+        @buffer_capacity: ::Integer
+        @flight_capacity: ::Integer
+
+        def initialize: (host_cid: ::String, peer_cid: ::String, version: ::Integer, is_client: bool, ?packet_number: ::Integer, ?peer_token: ::String, ?quic_logger: untyped?, ?spin_bit: bool) -> void
+        def packet_is_empty: () -> bool
+        def remaining_buffer_space: () -> ::Integer
+        def remaining_flight_space: () -> ::Integer
+        def flush: () -> [::Array[::String], ::Array[QuicSentPacket]]
+        def start_frame: (frame_type: ::Integer, ?capacity: ::Integer, ?handler: untyped?, ?handler_args: untyped) -> ::Raioquic::Buffer
+        def start_packet: (packet_type: ::Integer, crypto: ::Raioquic::Quic::Crypto::CryptoPair) -> void
+        def end_packet: () -> void
+        def flush_current_datagram: () -> void
+      end
+    end
+  end
+end

data/sig/raioquic/quic/rangeset.rbs

@@ -0,0 +1,17 @@
+module Raioquic
+  module Quic
+    class Rangeset
+      @ranges: ::Array[::Range[::Integer]]
+
+      def initialize: (?ranges: ::Array[::Range[::Integer]]) -> Rangeset
+      def list: () -> ::Array[::Range[::Integer]]
+      def add: (::Integer, ?(::Integer|nil)) -> void
+      def bounds: () -> ::Range[::Integer]
+      def length: () -> ::Integer
+      def subtract: (::Integer, ::Integer) -> void
+      def eql?: (untyped) -> bool
+      def ==: (untyped) -> bool
+      private def sort: () -> void
+    end
+  end
+end

data/sig/raioquic/quic/recovery.rbs

@@ -0,0 +1,142 @@
+module Raioquic
+  module Quic
+    module Recovery
+      K_PACKET_THRESHOLD: ::Integer
+      K_GRANULARITY: ::Float
+      K_TIME_THRESHOLD: ::Float
+      K_MICRO_SECOND: ::Float
+      K_SECOND: ::Float
+      K_MAX_DATAGRAM_SIZE: ::Integer
+      K_INITIAL_WINDOW: ::Integer
+      K_MINIMUM_WINDOW: ::Integer
+      K_LOSS_REDUCTION_FACTOR: ::Float
+
+      class QuicPacketSpace
+        type sent_packets = ::Hash[::Integer, ::Raioquic::Quic::PacketBuilder::QuicSentPacket]
+
+        attr_accessor sent_packets: sent_packets
+        attr_accessor ack_at: ::Float | nil
+        attr_accessor ack_eliciting_in_flight: ::Integer
+        attr_accessor loss_time: ::Float | nil
+        attr_accessor largest_acked_packet: ::Integer
+        attr_accessor expected_packet_number: ::Integer
+        attr_accessor largest_received_packet: ::Integer
+        attr_accessor largest_received_time: ::Float | nil
+        attr_accessor ack_queue: Rangeset
+        attr_accessor discarded: bool
+
+        @ack_at: ::Float | nil
+        @ack_queue: Rangeset
+        @discarded: bool
+        @expected_packet_number: ::Integer
+        @largest_received_packet: ::Integer
+        @largest_received_time: ::Float | nil
+        @ack_eliciting_in_flight: ::Integer
+        @largest_acked_packet: ::Integer
+        @loss_time: ::Float | nil
+        @sent_packets: sent_packets
+
+        def initialize: () -> void
+      end
+
+      class QuicPacketPacer
+        attr_reader bucket_max: ::Float
+        attr_reader bucket_time: ::Float
+        attr_reader packet_time: ::Float | nil
+        @bucket_max: ::Float
+        @bucket_time: ::Float
+        @evaluation_time: ::Float
+        @packet_time: ::Float | nil
+
+        def initialize: () -> void
+        def next_send_time: (now: ::Float) -> (::Float | nil)
+        def update_after_send: (now: ::Float) -> void
+        def update_bucket: (now: ::Float) -> void
+        def update_rate: (congestion_window: ::Integer, smoothed_rtt: ::Float) -> void
+      end
+
+      class QuicCongestionControl
+        attr_reader congestion_window: ::Numeric
+        attr_reader ssthresh: ::Integer | nil
+
+        attr_accessor bytes_in_flight: ::Integer
+
+        @bytes_in_flight: ::Integer
+        @congestion_window: ::Numeric
+        @congestion_recovery_start_time: ::Float
+        @congestion_stash: ::Numeric
+        @rtt_monitor: QuicRttMonitor
+        @ssthresh: ::Integer | nil
+
+        def initialize: () -> void
+        def on_packet_acked: (packet: ::Raioquic::Quic::PacketBuilder::QuicSentPacket) -> void
+        def on_packet_sent: (packet: ::Raioquic::Quic::PacketBuilder::QuicSentPacket) -> void
+        def on_packets_expired: (packets: ::Array[::Raioquic::Quic::PacketBuilder::QuicSentPacket]) -> void
+        def on_packets_lost: (packets: ::Array[::Raioquic::Quic::PacketBuilder::QuicSentPacket], now: ::Float) -> void
+        def on_rtt_measurement: (latest_rtt: ::Float, now: ::Float) -> void
+      end
+
+      class QuicPacketRecovery
+        attr_reader rtt_initialized: bool
+        attr_reader rtt_latest: ::Float
+        attr_reader rtt_min: ::Float
+        attr_reader rtt_smoothed: ::Float
+
+        attr_accessor spaces: ::Array[QuicPacketSpace]
+        attr_accessor peer_completed_address_validation: bool
+        attr_accessor pacer: QuicPacketPacer
+        attr_accessor max_ack_delay: ::Float
+
+        @max_ack_delay: ::Float
+        @peer_completed_address_validation: bool
+        @spaces: ::Array[QuicPacketSpace]
+        @logger: untyped
+        @quic_logger: ::Raioquic::Quic::Logger::QuicLoggerTrace | nil
+        @send_probe: (^() -> untyped) | nil
+        @pto_count: ::Integer
+        @rtt_initial: ::Float
+        @rtt_initialized: bool
+        @rtt_latest: ::Float
+        @rtt_min: ::Float
+        @rtt_smoothed: ::Float
+        @rtt_variance: ::Float
+        @time_of_last_sent_ack_eliciting_packet: ::Float
+        @cc: QuicCongestionControl
+        @pacer: QuicPacketPacer
+
+        def initialize: (initial_rtt: ::Float, peer_completed_address_validation: bool, ?send_probe: (^() -> untyped) | nil, ?logger: untyped, ?quic_logger: untyped) -> void
+        def discard_space: (space: QuicPacketSpace) -> void
+        def get_loss_detection_time: () -> ::Float
+        def get_probe_timeout: () -> ::Float
+        def on_ack_received: (space: QuicPacketSpace, ack_rangeset: Rangeset, ack_delay: ::Float, now: ::Float) -> void
+        def on_loss_detection_timeout: (now: ::Float) -> void
+        def on_packet_sent: (packet: ::Raioquic::Quic::PacketBuilder::QuicSentPacket, space: QuicPacketSpace) -> void
+        def reschedule_data: (now: ::Float) -> void
+        def detect_loss: (space: QuicPacketSpace, now: ::Float) -> void
+        def get_loss_space: () -> (QuicPacketSpace | nil)
+        def log_metrics_updated: (?bool log_rtt) -> void
+        def on_packets_lost: (packets: ::Array[::Raioquic::Quic::PacketBuilder::QuicSentPacket], space: QuicPacketSpace, now: ::Float) -> void
+      end
+
+      class QuicRttMonitor
+        attr_reader samples: ::Array[::Float]
+        attr_reader ready: bool
+        attr_reader increases: ::Integer
+
+        @increases: ::Integer
+        @last_time: ::Integer | nil
+        @ready: bool
+        @size: ::Integer
+        @filtered_min: ::Float | nil
+        @sample_idx: ::Integer
+        @sample_max: ::Float | nil
+        @sample_min: ::Float | nil
+        @sample_time: ::Float
+        @samples: ::Array[::Float]
+
+        def add_rtt: (rtt: ::Float) -> void
+        def is_rtt_increasing: (rtt: ::Float, now: ::Float) -> bool
+      end
+    end
+  end
+end

data/sig/raioquic/quic/stream.rbs

@@ -0,0 +1,87 @@
+module Raioquic::Quic::Stream
+  class FinalSizeError < StandardError
+  end
+
+  class StreamFinishedError < StandardError
+  end
+
+  class QuicStreamReceiver
+    attr_reader is_finished: bool
+    attr_reader buffer: ::String
+    attr_reader ranges: ::Raioquic::Quic::Rangeset
+    attr_reader buffer_start: ::Integer
+    attr_reader highest_offset: ::Integer
+    attr_reader stop_pending: bool
+
+    @highest_offset: ::Integer
+    @is_finished: bool
+    @stop_pending: bool
+    @buffer: ::String
+    @buffer_start: ::Integer
+    @final_size: ::Integer | nil
+    @ranges: ::Raioquic::Quic::Rangeset
+    @stream_id: ::Integer | nil
+    @stop_error_code: ::Integer | nil
+
+    def initialize: (?stream_id: ::Integer | nil, ?readable: bool) -> void
+    def get_stop_frame: () -> ::Raioquic::Quic::Packet::QuicStopSendingFrame
+    def handle_frame: (frame: ::Raioquic::Quic::Packet::QuicStreamFrame) -> (::Raioquic::Quic::Event::StreamDataReceived | nil)
+    def handle_reset: (final_size: :Integer, error_code: ::Integer) -> (::Raioquic::Quic::Event::StreamReset | nil)
+    def on_stop_sending_delivery: (delivery: ::Integer) -> void
+    def stop: (error_code: ::Integer) -> void
+    def pull_data: () -> ::String
+  end
+
+  class QuicStreamSender
+    attr_reader is_finished: bool
+    attr_reader buffer: ::String
+    attr_reader pending: ::Raioquic::Quic::Rangeset
+    attr_reader buffer_is_empty: bool
+    attr_reader reset_pending: bool
+    attr_accessor highest_offset: ::Integer
+
+    @buffer_is_empty: bool
+    @highest_offset: ::Integer
+    @is_finished: bool
+    @reset_pending: bool
+    @acked: ::Raioquic::Quic::Rangeset
+    @buffer: ::String
+    @buffer_fin: ::Integer | nil
+    @buffer_start: ::Integer
+    @buffer_stop: ::Integer
+    @pending: ::Raioquic::Quic::Rangeset
+    @pending_eof: bool
+    @reset_error_code: ::Integer | nil
+    @stream_id: ::Integer | nil
+
+    def initialize: (?stream_id: ::Integer | nil, writable: bool) -> void
+    def next_offset: () -> ::Integer
+    def get_frame: (max_size: ::Integer, ?max_offset: ::Integer | nil) -> (::Raioquic::Quic::Packet::QuicStreamFrame | nil)
+    def get_reset_frame: () -> ::Raioquic::Quic::Packet::QuicResetStreamFrame
+    def on_data_delivery: (delivery: ::Integer, start: ::Integer, stop: ::Integer) -> void
+    def on_reset_delivery: (delivery: ::Integer) -> void
+    def reset: (error_code: ::Integer) -> void
+    def write: (data: ::String, ?end_stream: bool) -> void
+  end
+
+  class QuicStream
+    attr_reader receiver: QuicStreamReceiver
+    attr_reader sender: QuicStreamSender
+    attr_reader stream_id: ::Integer | nil
+    attr_accessor is_blocked: bool
+    attr_accessor max_stream_data_local: ::Integer
+    attr_accessor max_stream_data_local_sent: ::Integer
+    attr_accessor max_stream_data_remote: ::Integer
+
+    @is_blocked: bool
+    @max_stream_data_local: ::Integer
+    @max_stream_data_local_sent: ::Integer
+    @max_stream_data_remote: ::Integer
+    @receiver: QuicStreamReceiver
+    @sender: QuicStreamSender
+    @stream_id: ::Integer | nil
+
+    def initialize: (?stream_id: ::Integer | nil, ?max_stream_data_local: ::Integer, ?max_stream_data_remote: ::Integer, ?readable: bool, ?writable: bool) -> bool
+    def is_finished: () -> bool
+  end
+end