nats-pure 2.5.0 → 2.7.0

data/lib/nats/io/jetstream.rb

@@ -16,6 +16,7 @@
 require_relative "kv"
 require_relative "jetstream/api"
 require_relative "jetstream/errors"
+require_relative "jetstream/header"
 require_relative "jetstream/js"
 require_relative "jetstream/manager"
 require_relative "jetstream/msg"
@@ -69,7 +70,19 @@ module NATS
     #   @return [Boolean] Indicates whether the published message is a duplicate.
     # @!attribute [domain] domain
     #   @return [String] JetStream Domain that processed the ack response.
-    PubAck = Struct.new(:stream, :seq, :duplicate, :domain, keyword_init: true)
+    # @!attribute [val] val
+    #   @return [String] Value of the counter after the increment, set when publishing to a stream with counters enabled, unless the message was a duplicate.
+    # @!attribute [batch] batch
+    #   @return [String] ID of the batch, set on the ack of an atomic batch commit.
+    # @!attribute [count] count
+    #   @return [Integer] Number of messages the batch stored, set on the ack of an atomic batch commit.
+    PubAck = Struct.new(:stream, :seq, :duplicate, :domain, :val, :batch, :count,
+      keyword_init: true) do
+      # Fields added by newer servers are ignored, so that they cannot break publish.
+      def initialize(opts = {})
+        super(**opts.slice(*members))
+      end
+    end
 
     # publish produces a message for JetStream.
     #
@@ -77,21 +90,51 @@ module NATS
     # @param payload [String] The payload of the message.
     # @param params [Hash] Options to customize the publish message request.
     # @option params [Float] :timeout Time to wait for an PubAck response or an error.
-    # @option params [Hash] :header NATS Headers to use for the message.
+    # @option params [Hash] :header NATS Headers to use for the message; the
+    #   options below replace those that they set.
     # @option params [String] :stream Expected Stream to which the message is being published.
+    # @option params [Integer, Symbol] :ttl Seconds after which the stream
+    #   removes the message, from 1 to 2**32, or :never to keep it past the max_age of
+    #   the stream. The stream needs allow_msg_ttl (requires nats-server v2.11.0).
+    # @option params [Hash] :schedule Makes the message a schedule, which
+    #   publishes it to the subject given as :target: once at the Time given
+    #   as :at; every so many whole seconds, given as :every; or on a :cron
+    #   expression with seconds, such as "0 30 * * * *", or "@hourly",
+    #   "@daily", "@weekly", "@monthly" or "@yearly", in UTC or the IANA
+    #   :time_zone, which only cron schedules take. :at is sent to the
+    #   nanosecond. :source publishes the last message of that subject
+    #   instead, :ttl gives the published messages a TTL, like the ttl
+    #   option, and rollup: true rolls up the target with each. The target
+    #   and source have to be subjects of the stream, which needs
+    #   allow_msg_schedules, and allow_msg_ttl for :ttl. Another schedule
+    #   on the subject replaces the schedule, and deleting its message stops
+    #   it. Requires nats-server v2.12.0 for :at, :target and :ttl, and
+    #   v2.14.0 for the others; v2.12 ignores :source and :rollup.
     # @raise [NATS::Timeout] When it takes too long to receive an ack response.
+    # @raise [ArgumentError] When an option is invalid, before the message is sent.
+    # @raise [NATS::JetStream::Error::APIError] When the stream refuses the
+    #   message, as a stream that does not allow TTLs refuses one with a TTL.
+    # @raise [NATS::JetStream::Error::NoStreamResponse] When no stream takes
+    #   the subject.
     # @return [PubAck] The pub ack response.
     def publish(subject, payload = "", **params)
       params[:timeout] ||= @opts[:timeout]
-      if params[:stream]
-        params[:header] ||= {}
-        params[:header][JS::Header::ExpectedStream] = params[:stream]
+      # The options add to a copy of the header, which the caller may reuse.
+      options = {
+        Header::EXPECTED_STREAM => (params[:stream] if params[:stream]),
+        Header::MSG_TTL => (msg_ttl(params[:ttl]) if params[:ttl])
+      }.compact
+      if (schedule = params[:schedule])
+        raise ArgumentError.new("nats: invalid schedule #{schedule.inspect}, expected a Hash") unless schedule.is_a?(Hash)
+
+        options.merge!(schedule_header(**schedule))
       end
+      header = options.empty? ? params[:header] : params[:header].to_h.merge(options)
 
       # Send message with headers.
       msg = NATS::Msg.new(subject: subject,
         data: payload,
-        header: params[:header])
+        header: header)
 
       begin
         resp = @nc.request_msg(msg, **params)
@@ -305,7 +348,7 @@ module NATS
         # If attempting to bind, then this is a hard error.
         raise e if params[:stream] && !multi_filter
 
-        config = if !(params[:config])
+        config = if !params[:config]
           JetStream::API::ConsumerConfig.new
         elsif params[:config].is_a?(JetStream::API::ConsumerConfig)
           params[:config]
@@ -322,8 +365,8 @@ module NATS
         add_consumer(stream, config)
       end
 
-      deliver = @nc.new_inbox
-      sub = @nc.subscribe(deliver)
+      # Each pull gets a reply of its own under the subscription.
+      sub = @nc.subscribe("#{@nc.new_inbox}.*")
       sub.extend(PullSubscription)
 
       consumer = params[:consumer]
@@ -336,5 +379,51 @@ module NATS
       )
       sub
     end
+
+    private
+
+    # msg_ttl formats a message TTL as the server takes it. Longer TTLs than
+    # 2**32 seconds, some 136 years, overflow in the server, which then
+    # removes the message at once.
+    def msg_ttl(ttl)
+      return "never" if ttl == :never
+      unless ttl.is_a?(Integer) && ttl.between?(1, 2**32)
+        raise ArgumentError.new("nats: invalid ttl #{ttl.inspect}, expected whole seconds from 1 to 2**32, or :never")
+      end
+
+      ttl.to_s
+    end
+
+    # schedule_header makes the headers of a message schedule.
+    def schedule_header(target:, at: nil, every: nil, cron: nil, source: nil, ttl: nil, time_zone: nil, rollup: nil)
+      pattern = if at.is_a?(Time)
+        "@at #{at.getutc.iso8601(9)}"
+      elsif every.is_a?(Integer) && every >= 1
+        "@every #{every}s"
+      elsif nonempty_string?(cron)
+        cron
+      end
+      unless pattern && [at, every, cron].compact.size == 1
+        raise ArgumentError.new("nats: a schedule needs one of at: a Time, every: whole seconds from 1, or cron: an expression")
+      end
+      raise ArgumentError.new("nats: a schedule needs a target subject") unless nonempty_string?(target)
+      raise ArgumentError.new("nats: invalid schedule source #{source.inspect}") unless source.nil? || nonempty_string?(source)
+      raise ArgumentError.new("nats: invalid schedule time zone #{time_zone.inspect}") unless time_zone.nil? || nonempty_string?(time_zone)
+      raise ArgumentError.new("nats: only cron: schedules take a time zone") if time_zone && !cron
+      raise ArgumentError.new("nats: invalid schedule rollup #{rollup.inspect}") unless [nil, true, false].include?(rollup)
+
+      {
+        Header::SCHEDULE => pattern,
+        Header::SCHEDULE_TARGET => target,
+        Header::SCHEDULE_SOURCE => source,
+        Header::SCHEDULE_TTL => (msg_ttl(ttl) if ttl),
+        Header::SCHEDULE_TIME_ZONE => time_zone,
+        Header::SCHEDULE_ROLLUP => ("sub" if rollup)
+      }.compact
+    end
+
+    def nonempty_string?(value)
+      value.is_a?(String) && !value.empty?
+    end
   end
 end

data/lib/nats/io/kv/api.rb

@@ -30,6 +30,10 @@ module NATS
         :republish,
         :direct,
         :validate_keys,
+        # Compress the bucket's stream with S2 (requires nats-server v2.10.0).
+        :compression,
+        # Freeform metadata of the bucket (requires nats-server v2.10.0).
+        :metadata,
         keyword_init: true
       ) do
         def initialize(opts = {})

data/lib/nats/io/kv/bucket_status.rb

@@ -35,6 +35,18 @@ module NATS
       def ttl
         @stream_info.config.max_age / ::NATS::NANOSECONDS
       end
+
+      # Whether the bucket's stream is compressed (requires nats-server v2.10.0).
+      def compressed?
+        compression = @stream_info.config.compression
+        !compression.nil? && compression != "none"
+      end
+
+      # The bucket's metadata, including the metadata that the server sets
+      # (requires nats-server v2.10.0).
+      def metadata
+        @stream_info.config.metadata
+      end
     end
   end
 end

data/lib/nats/io/kv/manager.rb

@@ -59,6 +59,10 @@ module NATS
           raise NATS::KeyValue::KeyHistoryTooLargeError
         end
 
+        unless [true, false, nil].include?(config.compression)
+          raise ArgumentError.new("nats: compression must be true or false")
+        end
+
         stream = JetStream::API::StreamConfig.new(
           name: "KV_#{config.bucket}",
           description: config.description,
@@ -76,7 +80,9 @@ module NATS
           max_msgs_per_subject: config.history,
           num_replicas: config.replicas,
           storage: config.storage,
-          republish: config.republish
+          republish: config.republish,
+          compression: config.compression ? "s2" : nil,
+          metadata: config.metadata
         )
 
         si = add_stream(stream)

data/lib/nats/io/kv.rb

@@ -31,7 +31,7 @@ module NATS
     ROLLUP = "Nats-Rollup"
 
     VALID_BUCKET_RE = /\A[a-zA-Z0-9_-]+$/
-    VALID_KEY_RE = /\A[-\/_=\.a-zA-Z0-9]+$/
+    VALID_KEY_RE = /\A[-\/_=.a-zA-Z0-9]+$/
 
     class << self
       def is_valid_key(key)
@@ -258,7 +258,8 @@ module NATS
     CONSUMER_STALLED_HDR = "Nats-Consumer-Stalled"
 
     # watch will be signaled when a key that matches the keys
-    # pattern is updated.
+    # pattern is updated. keys can also be an Array of patterns
+    # (requires nats-server v2.10.0); an empty Array watches all keys.
     # The first update after starting the watch is nil in case
     # there are no pending updates.
     def watch(keys, params = {})
@@ -267,13 +268,18 @@ module NATS
       params[:ignore_deletes] ||= false
       params[:idle_heartbeat] ||= 5 # seconds
       params[:inactive_threshold] ||= 5 * 60 # 5 minutes
-      subject = "#{@pre}#{keys}"
+      subject = if keys.is_a?(Array)
+        keys = [">"] if keys.empty?
+        keys.map { |key| "#{@pre}#{key}" }
+      else
+        "#{@pre}#{keys}"
+      end
       init_setup = new_cond
       init_setup_done = false
       nc = @js.nc
       watcher = KeyWatcher.new(@js)
 
-      deliver_policy = if !(params[:include_history])
+      deliver_policy = if !params[:include_history]
         "last_per_subject"
       end
 
@@ -294,7 +300,7 @@ module NATS
       }
 
       # watch_updates callback.
-      sub = @js.subscribe(subject, config: ordered) do |msg|
+      sub = @js.subscribe(subject, stream: @stream, config: ordered) do |msg|
         synchronize do
           if !init_setup_done
             init_setup.wait(@js.opts[:timeout])
@@ -327,15 +333,9 @@ module NATS
         meta = msg.metadata
         watcher.synchronize { watcher._active = true }
         # Track the sequences
-        #
-        # $JS.ACK.KV_TEST.CKRGrWpf.1.10.10.1739859923871837000.0
-        #
-        tokens = msg.reply.split(".")
-        sseq = tokens[5]
-        dseq = tokens[6]
         watcher.synchronize do
-          watcher._dseq = dseq.to_i + 1
-          watcher._sseq = sseq.to_i
+          watcher._dseq = meta.sequence.consumer + 1
+          watcher._sseq = meta.sequence.stream
         end
 
         # Keys() handling
@@ -385,6 +385,9 @@ module NATS
       begin
         cinfo = sub.consumer_info
         stream_name = cinfo.stream_name
+        # Snapshot the keys filter too: subscribe set it on the consumer,
+        # not on ordered, and a recreated consumer needs it.
+        filter = cinfo.config.to_h.slice(:filter_subject, :filter_subjects)
 
         synchronize do
           init_setup_done = true
@@ -423,9 +426,11 @@ module NATS
           current
         }
         if !active
-          ccreq = ordered.dup
+          ccreq = ordered.merge(filter)
           ccreq[:deliver_policy] = "by_start_sequence"
-          ccreq[:opt_start_seq] = watcher._sseq
+          # Resume after the last entry. With none yet, that is the start of
+          # the stream, so earlier revisions of the keys are replayed too.
+          ccreq[:opt_start_seq] = watcher._sseq + 1
           ccreq[:deliver_subject] = deliver_subject
           ccreq[:idle_heartbeat] = ordered[:idle_heartbeat]
           ccreq[:inactive_threshold] = ordered[:inactive_threshold]
@@ -465,6 +470,7 @@ module NATS
   class KeyWatcher
     include MonitorMixin
     include Enumerable
+
     attr_accessor :received, :pending, :_sub, :_updates, :_init_done, :_watcher_cond
     attr_accessor :_sseq, :_dseq, :_active, :_hb_task
 

data/lib/nats/io/parser.rb

@@ -17,7 +17,7 @@
 module NATS
   module Protocol
     MSG = /\AMSG\s+([^\s]+)\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?(\d+)\r\n/i
-    HMSG = /\AHMSG\s+([^\s]+)\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?([\d]+)\s+(\d+)\r\n/i
+    HMSG = /\AHMSG\s+([^\s]+)\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?(\d+)\s+(\d+)\r\n/i
     OK = /\A\+OK\s*\r\n/i
     ERR = /\A-ERR\s+('.+')?\r\n/i
     PING = /\APING\s*\r\n/i
@@ -98,12 +98,12 @@ module NATS
             return unless @needed && @buf.bytesize >= (@needed + CR_LF_SIZE)
             if @header_needed
               hbuf = @buf.slice(0, @header_needed)
-              payload = @buf.slice(@header_needed, (@needed - @header_needed))
+              payload = @buf.slice(@header_needed, @needed - @header_needed)
               @nc.send(:process_msg, @sub, @sid, @reply, payload, hbuf)
             else
               @nc.send(:process_msg, @sub, @sid, @reply, @buf.slice(0, @needed), nil)
             end
-            @buf = @buf.slice((@needed + CR_LF_SIZE), @buf.bytesize)
+            @buf = @buf.slice(@needed + CR_LF_SIZE, @buf.bytesize)
 
             @sub = @sid = @reply = @needed = @header_needed = nil
             @parse_state = AWAITING_CONTROL_LINE

data/lib/nats/io/subscription.rb

@@ -89,18 +89,19 @@ module NATS
     def next_msg(opts = {})
       timeout = opts[:timeout] ||= 0.5
       synchronize do
-        return @pending_queue.pop if !@pending_queue.empty?
+        if @pending_queue.empty?
+          # Wait for a bit until getting a signal.
+          MonotonicTime.with_nats_timeout(timeout) do
+            wait_for_msgs_cond.wait(timeout)
+          end
 
-        # Wait for a bit until getting a signal.
-        MonotonicTime.with_nats_timeout(timeout) do
-          wait_for_msgs_cond.wait(timeout)
+          raise NATS::Timeout if @pending_queue.empty?
         end
 
-        if !@pending_queue.empty?
-          return @pending_queue.pop
-        else
-          raise NATS::Timeout
-        end
+        # Decrease pending size since consumed already
+        msg = @pending_queue.pop
+        self.pending_size -= msg.data.size
+        msg
       end
     end
 
@@ -148,13 +149,20 @@ module NATS
         msg = pending_queue.pop(true)
         process(msg)
       rescue ThreadError # queue is empty
-        concurrency_semaphore.release
+        # No release here: the ensure below releases the permit; a second
+        # release would grow the semaphore beyond processing_concurrency.
       ensure
         concurrency_semaphore.release
         [concurrency_semaphore.available_permits, pending_queue.size].min.times do
           enqueue_processing(executor)
         end
       end
+    rescue Concurrent::RejectedExecutionError
+      # The executor is being shut down (the connection is closing,
+      # draining or reconnecting). Release the permit so the
+      # subscription can process messages again after a reconnect;
+      # the message stays in pending_queue.
+      concurrency_semaphore.release
     end
   end
 end

data/lib/nats/io/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright 2016-2025 The NATS Authors
+# Copyright 2016-2026 The NATS Authors
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -17,7 +17,7 @@
 module NATS
   module IO
     # VERSION is the version of the client announced on CONNECT to the server.
-    VERSION = "2.5.0"
+    VERSION = "2.7.0"
 
     # LANG is the lang runtime of the client announced on CONNECT to the server.
     LANG = "#{RUBY_ENGINE}#{RUBY_VERSION}".freeze

data/lib/nats/io/websocket.rb

@@ -47,23 +47,28 @@ module NATS
       end
 
       def read(max_bytes = MAX_SOCKET_READ_BYTES, deadline = nil)
-        data = super
-        @frame << data
-        result = []
-        while (msg = @frame.next)
-          result << msg
+        # Hand over what read_line decoded beyond its last line first,
+        # otherwise those bytes are lost once the read loop takes over.
+        if @line_buf && !@line_buf.empty?
+          return @line_buf.slice!(0, @line_buf.bytesize)
         end
-        result.join
+
+        read_frames(max_bytes, deadline)
       end
 
       def read_line(deadline = nil)
-        data = super
-        @frame << data
-        result = []
-        while (msg = @frame.next)
-          result << msg
+        @line_buf ||= +""
+        loop do
+          if (idx = @line_buf =~ /\r?\n/)
+            return @line_buf.slice!(0, idx + Regexp.last_match(0).length)
+          end
+
+          # Pull more data from the wire; never from @line_buf itself,
+          # or a partial line would be fed back forever.
+          data = read_frames(MAX_SOCKET_READ_BYTES, deadline)
+          return nil unless data
+          @line_buf << data
         end
-        result.join
       end
 
       def write(data, deadline = nil)
@@ -72,6 +77,21 @@ module NATS
         frame = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: :binary, version: @handshake.version)
         super(frame.to_s)
       end
+
+      private
+
+      # Reads from the socket and returns the payloads of all complete
+      # frames decoded so far.
+      def read_frames(max_bytes, deadline)
+        data = Socket.instance_method(:read).bind_call(self, max_bytes, deadline)
+        @frame << data
+        [].tap do |parts|
+          while (msg = @frame.next)
+            payload = msg.respond_to?(:data) ? msg.data : msg
+            parts << payload if payload
+          end
+        end.join
+      end
     end
   end
 end

data/lib/nats/service/validator.rb

@@ -6,8 +6,8 @@ module NATS
       REGEX = {
         name: /[A-Za-z0-9\-_]+$/,
         version: /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/,
-        subject: /^[^ >]*[>]?$/,
-        queue: /^[^ >]*[>]?$/
+        subject: /^[^ >]*>?$/,
+        queue: /^[^ >]*>?$/
       }.freeze
 
       class << self

data/sig/nats/io/jetstream/api.rbs

@@ -7,18 +7,27 @@ module NATS
       class SequenceInfo < Struct[Integer]
       end
 
-      class ConsumerInfo < Struct[String | NATS::JetStream::API::ConsumerConfig | NATS::JetStream::API::SequenceInfo | Integer | Hash[Symbol, untyped]]
+      class PriorityGroupState < Struct[String | Time]
       end
 
-      class ConsumerConfig < Struct[String | Integer]
+      class ConsumerInfo < Struct[String | NATS::JetStream::API::ConsumerConfig | NATS::JetStream::API::SequenceInfo | Integer | Hash[Symbol, untyped] | Time | bool | Array[NATS::JetStream::API::PriorityGroupState]]
+      end
+
+      class ConsumerConfig < Struct[String | Integer | Time | Array[String]]
         def to_json: (*Hash[untyped, untyped]) -> String
       end
 
+      class ConsumerPauseResponse < Struct[bool | Time | Integer]
+      end
+
+      class ConsumerResetResponse < Struct[NATS::JetStream::API::ConsumerInfo | Integer]
+      end
+
       class StreamConfig < Struct[String | Hash[Symbol, untyped] | NATS::JetStream::API::StreamState | bool | Integer]
         def to_json: (*Hash[untyped, untyped]) -> String
       end
 
-      class StreamInfo < Struct[String | Hash[Symbol, untyped]]
+      class StreamInfo < Struct[String | Hash[Symbol, untyped] | Array[Hash[Symbol, untyped]] | Time]
       end
 
       class StreamState < Struct[Integer]

data/sig/nats/io/jetstream/errors.rbs

@@ -49,6 +49,18 @@ module NATS
 
       class BadRequest < NATS::JetStream::Error::APIError
       end
+
+      class ConsumerAlreadyExists < NATS::JetStream::Error::BadRequest
+      end
+
+      class ConsumerDoesNotExist < NATS::JetStream::Error::BadRequest
+      end
+
+      class ConsumerInvalidReset < NATS::JetStream::Error::BadRequest
+      end
+
+      class PinIdMismatch < NATS::JetStream::Error::APIError
+      end
     end
   end
 end

data/sig/nats/io/jetstream/header.rbs

@@ -0,0 +1,33 @@
+module NATS
+  class JetStream
+    module Header
+      MSG_ID: 'Nats-Msg-Id'
+      EXPECTED_STREAM: 'Nats-Expected-Stream'
+      EXPECTED_LAST_SEQUENCE: 'Nats-Expected-Last-Sequence'
+      EXPECTED_LAST_SUBJECT_SEQUENCE: 'Nats-Expected-Last-Subject-Sequence'
+      EXPECTED_LAST_SUBJECT_SEQUENCE_SUBJECT: 'Nats-Expected-Last-Subject-Sequence-Subject'
+      EXPECTED_LAST_MSG_ID: 'Nats-Expected-Last-Msg-Id'
+      ROLLUP: 'Nats-Rollup'
+      MSG_TTL: 'Nats-TTL'
+      MARKER_REASON: 'Nats-Marker-Reason'
+      STREAM: 'Nats-Stream'
+      SUBJECT: 'Nats-Subject'
+      SEQUENCE: 'Nats-Sequence'
+      TIME_STAMP: 'Nats-Time-Stamp'
+      LAST_SEQUENCE: 'Nats-Last-Sequence'
+      STREAM_SOURCE: 'Nats-Stream-Source'
+      BATCH_ID: 'Nats-Batch-Id'
+      BATCH_SEQUENCE: 'Nats-Batch-Sequence'
+      BATCH_COMMIT: 'Nats-Batch-Commit'
+      SCHEDULE: 'Nats-Schedule'
+      SCHEDULE_TARGET: 'Nats-Schedule-Target'
+      SCHEDULE_SOURCE: 'Nats-Schedule-Source'
+      SCHEDULE_TTL: 'Nats-Schedule-TTL'
+      SCHEDULE_TIME_ZONE: 'Nats-Schedule-Time-Zone'
+      SCHEDULE_ROLLUP: 'Nats-Schedule-Rollup'
+      SCHEDULER: 'Nats-Scheduler'
+      SCHEDULE_NEXT: 'Nats-Schedule-Next'
+      REQUIRED_API_LEVEL: 'Nats-Required-Api-Level'
+    end
+  end
+end

data/sig/nats/io/jetstream/js/header.rbs

@@ -11,6 +11,7 @@ module NATS
         ExpectedLastMsgID: 'Nats-Expected-Last-Msg-Id'
         LastConsumerSeq: 'Nats-Last-Consumer'
         LastStreamSeq: 'Nats-Last-Stream'
+        PinId: 'Nats-Pin-Id'
       end
     end
   end

data/sig/nats/io/jetstream/js/status.rbs

@@ -6,6 +6,7 @@ module NATS
         NoMsgs: '404'
         NotFound: '404'
         RequestTimeout: '408'
+        PinIdMismatch: '423'
         ServiceUnavailable: '503'
       end
     end

data/sig/nats/io/jetstream/js.rbs

@@ -6,11 +6,13 @@ module NATS
       # class << self
       def self.next_req_to_json: (Hash[Symbol, untyped]) -> String
 
+      def self.parse_time: (String?) -> Time?
+
       def self.is_status_msg: (NATS::Msg) -> bool
 
       def self.check_503_error: (NATS::Msg) -> void
 
-      def self.from_msg: (NATS::Msg) -> NATS::JetStream::API::Error
+      def self.from_msg: (NATS::Msg) -> (NATS::JetStream::API::Error | NATS::JetStream::Error::PinIdMismatch)
 
       def self.from_error: (Hash[Symbol, untyped]) -> (
           NATS::JetStream::Error::ServiceUnavailable |

data/sig/nats/io/jetstream/manager.rbs

@@ -9,12 +9,24 @@ module NATS
 
       def delete_stream: (String, ?Hash[Symbol, untyped]) -> bool
 
-      def add_consumer: (String, JetStream::API::ConsumerConfig, ?Hash[Symbol, untyped]) -> JetStream::API::ConsumerInfo
+      def add_consumer: (String, JetStream::API::ConsumerConfig | Hash[Symbol, untyped], ?Hash[Symbol, untyped]) -> JetStream::API::ConsumerInfo
+
+      def create_consumer: (String, JetStream::API::ConsumerConfig | Hash[Symbol, untyped], ?Hash[Symbol, untyped]) -> JetStream::API::ConsumerInfo
+
+      def update_consumer: (String, JetStream::API::ConsumerConfig | Hash[Symbol, untyped], ?Hash[Symbol, untyped]) -> JetStream::API::ConsumerInfo
 
       def consumer_info: (String, String, ?Hash[Symbol, untyped]) -> JetStream::API::ConsumerInfo
 
       def delete_consumer: (String, String, ?Hash[Symbol, untyped]) -> bool
 
+      def pause_consumer: (String, String, Time | String, ?Hash[Symbol, untyped]) -> JetStream::API::ConsumerPauseResponse
+
+      def resume_consumer: (String, String, ?Hash[Symbol, untyped]) -> JetStream::API::ConsumerPauseResponse
+
+      def unpin_consumer: (String, String, String, ?Hash[Symbol, untyped]) -> bool
+
+      def reset_consumer: (String, String, ?Hash[Symbol, untyped]) -> JetStream::API::ConsumerResetResponse
+
       def find_stream_name_by_subject: (String, ?Hash[Symbol, untyped]) -> String
 
       def get_msg: (String, ?Hash[Symbol, untyped]) -> JetStream::API::RawStreamMsg
@@ -25,9 +37,17 @@ module NATS
 
       private
 
+      def upsert_consumer: (String, JetStream::API::ConsumerConfig | Hash[Symbol, untyped], String?, Hash[Symbol, untyped]) -> JetStream::API::ConsumerInfo
+
+      def request_pause: (String, String, Hash[Symbol, String], Hash[Symbol, untyped]) -> JetStream::API::ConsumerPauseResponse
+
+      def rfc3339: (Time | String | nil) -> String?
+
       def api_request: (String, String, ?Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
 
       def _lift_msg_to_raw_msg: (NATS::Msg) -> JetStream::API::RawStreamMsg
+
+      def stream_config_json: (JetStream::API::StreamConfig) -> String
     end
   end
 end