tarantool-client 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 312e13dccce60b22bb3e74005e914cadcbf6dbbf096d378759a2697e6c0a1e8c
-  data.tar.gz: f0fd02d53f7bbb97ee347f7b81b1e9a9f83476a5af871042036b025c9cbb8060
+  metadata.gz: 046c9d293325df27a2971c6c6257cd6691e3e6c2cb565ea41eb9cb1aa5a2ccf3
+  data.tar.gz: 2dc134d5da8d6f5a99fd8b73f28340ae022ae9243c62d750287e35e5d088d159
 SHA512:
-  metadata.gz: 81512742b3dfc97f726a1af22d2bbfd578cd083cc2dd75f3cbe3c4004bde4e1e73ee21ba03675581b7586d590c2624e6287bc8040ee281e3b3fe85ef8c093f4e
-  data.tar.gz: 8e4390ef152eab60197e2a5822a132266b12c4eb567801017a2dd0308426109823230b86df6700b1e220f9353f9de892cbe634acaa4d89578ff84c99167ead89
+  metadata.gz: 8cb3cae463060a270127eea6427eacef15edd25ec159d6d377f97af2692d9fc7fade4fef6b871943cfe78387d740621c5061b583bfe2ae755ca06f8e8a7f282c
+  data.tar.gz: c456c5a8fa8a0c8de99804f29fd0c36831a35f692391c3cda7c582f1901fc7ee46cbf7fc709fed866bcba121b6fa4b5de6bbc4da6a5ea8ebe3e380f99a133a18

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.3.1 (2026-10-18)
+
+- Allows `bigdecimal` 4.x, the version Ruby 4 ships with.
+
 ## 0.3.0 (2026-10-17)
 
 - `select(fetch_position: true)` returns a `Page` with the server-side position of the last tuple; `after:` takes that position (String) as well as a tuple.

data/README.md

@@ -309,6 +309,8 @@ Don't create multikey indexes on these containers: with `memtx_use_mvcc_engine =
 `Watcher` (returned by `watch`), `SqlResult`, `PreparedStatement`, `SpaceInfo`, `IndexInfo`, `Row`, `Page`, `Configuration`
 (returned by `client.config`), `Tarantool::Client::UUID`, `Interval`, `BoxError`, and the error classes above.
 
+RBS signatures for this API ship with the gem in `sig/`.
+
 Everything else, including anything tagged `@api private` in its source comment, is an implementation detail
 and may change in any release.
 

data/lib/tarantool/client/configuration.rb

@@ -24,15 +24,15 @@ module Tarantool
 
       def self.parse_uri(uri)
         return {} if uri.nil?
-        return parse_unix_uri(uri) if uri.match?(%r{\Aunix/?:})
+        return parse_unix_uri(uri) if uri.match?(Configuration::UNIX_URI)
 
         parse_tcp_uri(uri)
       end
 
       def self.parse_unix_uri(uri)
-        match = %r{\Aunix/?:(?://(?=/))?(.+)\z}.match(uri)
+        match = Configuration::UNIX_PATH.match(uri)
         path = match && match[1]
-        raise ArgumentError, 'invalid Tarantool URI' if path.nil? || path.match?(%r{\A/*\z})
+        raise ArgumentError, 'invalid Tarantool URI' if path.nil? || path.match?(Configuration::EMPTY_PATH)
 
         { path: path }
       end
@@ -84,5 +84,11 @@ module Tarantool
         klass.name ? "#<#{klass.name}>" : klass.inspect
       end
     end
+
+    class Configuration
+      UNIX_URI = %r{\Aunix/?:}
+      UNIX_PATH = %r{\Aunix/?:(?://(?=/))?(.+)\z}
+      EMPTY_PATH = %r{\A/*\z}
+    end
   end
 end

data/lib/tarantool/client/pool/member_role.rb

@@ -3,8 +3,8 @@
 module Tarantool
   class Client
     class Pool
-      # The role a member's instance reports through box.status. Includers set @lock, @changed, @read_only and
-      # @instrumentation.
+      # The role a member's instance reports through box.status. Includers set @lock, @changed, @read_only
+      # and @instrumentation.
       # @api private
       module MemberRole
         private

data/lib/tarantool/client/protocol/greeting.rb

@@ -6,8 +6,6 @@ module Tarantool
       # Greeting sent by the server on connect: a 64-byte banner and a 64-byte base64 salt line.
       # @api private
       Greeting = Data.define(:version, :salt) do
-        self::BANNER_VERSION = /\ATarantool (\S+)/
-
         def self.parse(bytes)
           banner = bytes.byteslice(0, 64)
           version = banner[Greeting::BANNER_VERSION, 1]
@@ -16,6 +14,10 @@ module Tarantool
           new(version:, salt: bytes.byteslice(64, 64).strip.unpack1('m'))
         end
       end
+
+      class Greeting
+        BANNER_VERSION = /\ATarantool (\S+)/
+      end
     end
   end
 end

data/lib/tarantool/client/uuid.rb

@@ -4,8 +4,6 @@ module Tarantool
   class Client
     # A Tarantool uuid value; only instances of this type are sent as MP_EXT uuid, never plain strings.
     UUID = Data.define(:value) do
-      self::FORMAT = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/
-
       def initialize(value:)
         raise ArgumentError, "invalid UUID: #{value.inspect}" unless value.is_a?(String) && value.match?(UUID::FORMAT)
 
@@ -16,5 +14,9 @@ module Tarantool
         value
       end
     end
+
+    class UUID
+      FORMAT = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/
+    end
   end
 end

data/lib/tarantool/client/version.rb

@@ -2,6 +2,6 @@
 
 module Tarantool
   class Client
-    VERSION = '0.3.0'
+    VERSION = '0.3.1'
   end
 end

data/sig/tarantool/client/pool.rbs

@@ -0,0 +1,41 @@
+module Tarantool
+  class Client
+    # Clients for the instances of one replica set, routed by the role each reports through box.status.
+    class Pool
+      type mode = :rw | :ro | :prefer_ro | :prefer_rw | :any
+
+      MODES: Array[mode]
+
+      def initialize: (Array[String] addresses, ?host: String, ?port: Integer, ?path: String?, ?user: String?,
+                       ?password: String?, ?connect_timeout: Numeric?, ?request_timeout: Numeric?, ?reconnect: bool,
+                       ?reconnect_attempts: Numeric, ?reconnect_delay: Numeric, ?reconnect_max_delay: Numeric,
+                       ?max_frame_size: Integer, ?instrumenter: _Instrumenter?, ?logger: _Logger?) -> void
+
+      def ping: (?mode: mode, ?timeout: Numeric?) -> true
+      def space_info: (space_ref space, ?mode: mode, ?timeout: Numeric?) -> SpaceInfo
+      def select: (space_ref space, ?key key, ?mode: mode, ?index: index_ref, ?limit: Integer, ?offset: Integer,
+                   ?iterator: iterator, ?after: cursor?, ?fetch_position: bool, ?as: shape,
+                   ?timeout: Numeric?) -> (Array[row] | Page)
+      def insert: (space_ref space, tuple_input tuple, ?mode: mode, ?as: shape, ?timeout: Numeric?) -> row
+      def replace: (space_ref space, tuple_input tuple, ?mode: mode, ?as: shape, ?timeout: Numeric?) -> row
+      def update: (space_ref space, key key, Array[operation] operations, ?mode: mode, ?index: index_ref, ?as: shape,
+                   ?timeout: Numeric?) -> row?
+      def upsert: (space_ref space, tuple_input tuple, Array[operation] operations, ?mode: mode,
+                   ?timeout: Numeric?) -> nil
+      def delete: (space_ref space, key key, ?mode: mode, ?index: index_ref, ?as: shape, ?timeout: Numeric?) -> row?
+      def delete_by: (space_ref space, key key, index: index_ref, ?mode: mode, ?iterator: iterator,
+                      ?batch_size: Integer, ?timeout: Numeric?) -> Integer
+      def call: (String function_name, ?Array[untyped] arguments, ?mode: mode, ?timeout: Numeric?,
+                 ?on_push: (^(untyped message) -> void)?) -> Array[untyped]
+      def eval: (String expression, ?Array[untyped] arguments, ?mode: mode, ?timeout: Numeric?) -> Array[untyped]
+      def execute: (String | Integer | PreparedStatement sql, ?Array[untyped] bindings, ?mode: mode,
+                    ?timeout: Numeric?) -> SqlResult
+      def prepare: (String sql, ?mode: mode, ?timeout: Numeric?) -> PreparedStatement
+
+      # Always on a writable instance.
+      def transaction: [T] (?isolation: isolation, ?timeout: Numeric?) { (Stream) -> T } -> T
+      def close: () -> void
+      def inspect: () -> String
+    end
+  end
+end

data/sig/tarantool/client/stream.rbs

@@ -0,0 +1,26 @@
+module Tarantool
+  class Client
+    # The operations of one interactive transaction, yielded by Client#transaction and Pool#transaction.
+    class Stream
+      def ping: (?timeout: Numeric?) -> true
+      def space_info: (space_ref space, ?timeout: Numeric?) -> SpaceInfo
+      def select: (space_ref space, ?key key, ?index: index_ref, ?limit: Integer, ?offset: Integer,
+                   ?iterator: iterator, ?after: cursor?, ?fetch_position: bool, ?as: shape,
+                   ?timeout: Numeric?) -> (Array[row] | Page)
+      def insert: (space_ref space, tuple_input tuple, ?as: shape, ?timeout: Numeric?) -> row
+      def replace: (space_ref space, tuple_input tuple, ?as: shape, ?timeout: Numeric?) -> row
+      def update: (space_ref space, key key, Array[operation] operations, ?index: index_ref, ?as: shape,
+                   ?timeout: Numeric?) -> row?
+      def upsert: (space_ref space, tuple_input tuple, Array[operation] operations, ?timeout: Numeric?) -> nil
+      def delete: (space_ref space, key key, ?index: index_ref, ?as: shape, ?timeout: Numeric?) -> row?
+      def delete_by: (space_ref space, key key, index: index_ref, ?iterator: iterator, ?batch_size: Integer,
+                      ?timeout: Numeric?) -> Integer
+      def call: (String function_name, ?Array[untyped] arguments, ?timeout: Numeric?,
+                 ?on_push: (^(untyped message) -> void)?) -> Array[untyped]
+      def eval: (String expression, ?Array[untyped] arguments, ?timeout: Numeric?) -> Array[untyped]
+      def execute: (String | Integer | PreparedStatement sql, ?Array[untyped] bindings, ?timeout: Numeric?) -> SqlResult
+      # Raises TransactionError: prepare on the client, execute the statement here.
+      def prepare: (*untyped) -> bot
+    end
+  end
+end

data/sig/tarantool/client/values.rbs

@@ -0,0 +1,179 @@
+module Tarantool
+  class Client
+    # Subscription returned by Client#watch.
+    class Watcher
+      attr_reader key: String
+
+      def unwatch: () -> nil
+    end
+
+    # Server-side prepared SQL statement, bound to the session that prepared it.
+    class PreparedStatement
+      attr_reader id: Integer
+
+      def execute: (?Array[untyped] bindings, ?timeout: Numeric?) -> SqlResult
+      def close: (?timeout: Numeric?) -> nil
+    end
+
+    # Rows and column names of an SQL query, or the counters of a data-changing statement.
+    class SqlResult < Data
+      attr_reader rows: Array[Array[untyped]]
+      attr_reader columns: Array[String]
+      attr_reader row_count: Integer?
+      attr_reader autoincrement_ids: Array[Integer]
+
+      def self.new: (rows: Array[Array[untyped]], columns: Array[String], row_count: Integer?,
+                     autoincrement_ids: Array[Integer]) -> SqlResult
+      def with: (?rows: Array[Array[untyped]], ?columns: Array[String], ?row_count: Integer?,
+                 ?autoincrement_ids: Array[Integer]) -> SqlResult
+    end
+
+    # A tuple as the server returned it, with its fields by name. Returned for `as: :row`.
+    class Row < Data
+      attr_reader tuple: tuple
+      attr_reader attributes: row_hash
+
+      def self.new: (tuple: tuple, attributes: row_hash) -> Row
+      def with: (?tuple: tuple, ?attributes: row_hash) -> Row
+    end
+
+    # One page of a select asked with `fetch_position: true`.
+    class Page < Data
+      include Enumerable[row]
+
+      attr_reader tuples: Array[row]
+      # Opaque, tied to the index and iterator that produced it; nil when the page is empty.
+      attr_reader position: String?
+
+      def self.new: (tuples: Array[row], position: String?) -> Page
+      def with: (?tuples: Array[row], ?position: String?) -> Page
+      def each: () { (row) -> void } -> Array[row]
+              | () -> Enumerator[row, Array[row]]
+      def empty?: () -> bool
+      def size: () -> Integer
+    end
+
+    # Format and indexes of a space from the loaded schema; `indexes` maps names to IndexInfo in id order.
+    class SpaceInfo < Data
+      attr_reader id: Integer
+      attr_reader name: String
+      attr_reader fields: Array[SpaceInfo::Field]
+      attr_reader indexes: Hash[String, IndexInfo]
+
+      def self.new: (id: Integer, name: String, fields: Array[SpaceInfo::Field], indexes: Hash[String, IndexInfo]) -> SpaceInfo
+      def with: (?id: Integer, ?name: String, ?fields: Array[SpaceInfo::Field], ?indexes: Hash[String, IndexInfo]) -> SpaceInfo
+      def primary_index: () -> IndexInfo?
+      def to_hash: (tuple tuple) -> row_hash
+      # An unknown name raises UnknownFieldError; missing fields go out as nil.
+      def to_tuple: (Hash[Symbol | String | Integer, untyped] hash) -> tuple
+
+      class Field < Data
+        attr_reader name: String
+        attr_reader type: String
+        attr_reader is_nullable: bool
+
+        def self.new: (name: String, type: String, is_nullable: bool) -> Field
+        def with: (?name: String, ?type: String, ?is_nullable: bool) -> Field
+      end
+    end
+
+    # One index of a space.
+    class IndexInfo < Data
+      attr_reader id: Integer
+      attr_reader name: String
+      attr_reader type: String
+      attr_reader unique: bool
+      attr_reader parts: Array[IndexInfo::Part]
+
+      def self.new: (id: Integer, name: String, type: String, unique: bool, parts: Array[IndexInfo::Part]) -> IndexInfo
+      def with: (?id: Integer, ?name: String, ?type: String, ?unique: bool, ?parts: Array[IndexInfo::Part]) -> IndexInfo
+
+      # `fieldno` is 0-based; `name` is nil for a field beyond the space format.
+      class Part < Data
+        attr_reader fieldno: Integer
+        attr_reader name: String?
+        attr_reader type: String
+        attr_reader is_nullable: bool
+        attr_reader path: String?
+
+        def self.new: (fieldno: Integer, name: String?, type: String, is_nullable: bool, path: String?) -> Part
+        def with: (?fieldno: Integer, ?name: String?, ?type: String, ?is_nullable: bool, ?path: String?) -> Part
+      end
+    end
+
+    # A Tarantool uuid; only instances of this type are sent as MP_EXT uuid.
+    class UUID < Data
+      FORMAT: Regexp
+
+      attr_reader value: String
+
+      def self.new: (String value) -> UUID
+                  | (value: String) -> UUID
+      def with: (?value: String) -> UUID
+      def to_s: () -> String
+    end
+
+    # A Tarantool datetime.interval; adjust is :none, :excess or :last.
+    class Interval < Data
+      type adjust = :none | :excess | :last
+
+      attr_reader year: Integer
+      attr_reader month: Integer
+      attr_reader week: Integer
+      attr_reader day: Integer
+      attr_reader hour: Integer
+      attr_reader min: Integer
+      attr_reader sec: Integer
+      attr_reader nsec: Integer
+      attr_reader adjust: adjust
+
+      def self.new: (?year: Integer, ?month: Integer, ?week: Integer, ?day: Integer, ?hour: Integer, ?min: Integer,
+                     ?sec: Integer, ?nsec: Integer, ?adjust: adjust) -> Interval
+      def with: (?year: Integer, ?month: Integer, ?week: Integer, ?day: Integer, ?hour: Integer, ?min: Integer,
+                 ?sec: Integer, ?nsec: Integer, ?adjust: adjust) -> Interval
+    end
+
+    # A box.error object returned as data (MP_ERROR), with its cause chain.
+    class BoxError < Data
+      attr_reader type: String?
+      attr_reader message: String?
+      attr_reader code: Integer?
+      attr_reader file: String?
+      attr_reader line: Integer?
+      attr_reader errno: Integer?
+      attr_reader fields: Hash[String, untyped]?
+      attr_reader cause: BoxError?
+
+      def self.new: (type: String?, message: String?, code: Integer?, file: String?, line: Integer?, errno: Integer?,
+                     fields: Hash[String, untyped]?, cause: BoxError?) -> BoxError
+      def with: (?type: String?, ?message: String?, ?code: Integer?, ?file: String?, ?line: Integer?, ?errno: Integer?,
+                 ?fields: Hash[String, untyped]?, ?cause: BoxError?) -> BoxError
+    end
+
+    # Immutable connection settings; `inspect` and `to_s` hide the password, `to_h` keeps it.
+    class Configuration < Data
+      attr_reader host: String
+      attr_reader port: Integer
+      attr_reader path: String?
+      attr_reader user: String?
+      attr_reader password: String?
+      attr_reader connect_timeout: Numeric?
+      attr_reader request_timeout: Numeric?
+      attr_reader reconnect: bool
+      attr_reader reconnect_attempts: Numeric
+      attr_reader reconnect_delay: Numeric
+      attr_reader reconnect_max_delay: Numeric
+      attr_reader max_frame_size: Integer
+      attr_reader instrumenter: _Instrumenter?
+      attr_reader logger: _Logger?
+
+      def self.build: (?String? uri, ?host: String, ?port: Integer, ?path: String?, ?user: String?, ?password: String?,
+                       ?connect_timeout: Numeric?, ?request_timeout: Numeric?, ?reconnect: bool,
+                       ?reconnect_attempts: Numeric, ?reconnect_delay: Numeric, ?reconnect_max_delay: Numeric,
+                       ?max_frame_size: Integer, ?instrumenter: _Instrumenter?, ?logger: _Logger?) -> Configuration
+      def address: () -> String
+      def inspect: () -> String
+      def to_s: () -> String
+    end
+  end
+end

data/sig/tarantool/client.rbs

@@ -0,0 +1,73 @@
+module Tarantool
+  # Connection to one Tarantool instance.
+  class Client
+    VERSION: String
+
+    # A space or index, by name or numeric id.
+    type space_ref = String | Symbol | Integer
+    type index_ref = String | Symbol | Integer
+    # A tuple as sent and received: an Array of msgpack values.
+    type tuple = Array[untyped]
+    # A tuple keyed by field name; fields beyond the format are keyed by their 0-based position.
+    type row_hash = Hash[Symbol | Integer, untyped]
+    # Tuples go out as Arrays or as Hashes keyed by field name (Symbol or String).
+    type tuple_input = tuple | Hash[Symbol | String, untyped]
+    # One msgpack value of a key part.
+    type scalar = Integer | Float | String | bool | nil | BigDecimal | Time | UUID | Interval
+    # An index key: the parts as an Array, or one scalar for a single-part key.
+    type key = Array[untyped] | scalar
+    type iterator = :eq | :req | :all | :lt | :le | :ge | :gt | :bits_all_set | :bits_any_set | :bits_all_not_set |
+                    :overlaps | :neighbor | :np | :pp
+    type shape = :tuple | :hash | :row
+    # One update operation, e.g. ['=', 'name', value] or ['+', 2, 1]; splice operations have five elements.
+    type operation = Array[untyped]
+    # What select returns for one tuple, by `as:`.
+    type row = tuple | row_hash | Row
+    type isolation = :default | :read_committed | :read_confirmed | :best_effort | :linearizable
+    # A position from Page#position, or the last tuple of the previous page.
+    type cursor = String | tuple
+
+    interface _Instrumenter
+      def instrument: (String name, Hash[Symbol, untyped] payload) { () -> untyped } -> untyped
+    end
+
+    interface _Logger
+      def debug: (?untyped message) ?{ () -> untyped } -> untyped
+      def info: (?untyped message) ?{ () -> untyped } -> untyped
+      def warn: (?untyped message) ?{ () -> untyped } -> untyped
+      def error: (?untyped message) ?{ () -> untyped } -> untyped
+    end
+
+    attr_reader config: Configuration
+
+    def initialize: (?String? uri, ?host: String, ?port: Integer, ?path: String?, ?user: String?, ?password: String?,
+                     ?connect_timeout: Numeric?, ?request_timeout: Numeric?, ?reconnect: bool,
+                     ?reconnect_attempts: Numeric, ?reconnect_delay: Numeric, ?reconnect_max_delay: Numeric,
+                     ?max_frame_size: Integer, ?instrumenter: _Instrumenter?, ?logger: _Logger?) -> void
+
+    def ping: (?timeout: Numeric?) -> true
+    def space_info: (space_ref space, ?timeout: Numeric?) -> SpaceInfo
+    def select: (space_ref space, ?key key, ?index: index_ref, ?limit: Integer, ?offset: Integer, ?iterator: iterator,
+                 ?after: cursor?, ?fetch_position: bool, ?as: shape, ?timeout: Numeric?) -> (Array[row] | Page)
+    def insert: (space_ref space, tuple_input tuple, ?as: shape, ?timeout: Numeric?) -> row
+    def replace: (space_ref space, tuple_input tuple, ?as: shape, ?timeout: Numeric?) -> row
+    def update: (space_ref space, key key, Array[operation] operations, ?index: index_ref, ?as: shape,
+                 ?timeout: Numeric?) -> row?
+    def upsert: (space_ref space, tuple_input tuple, Array[operation] operations, ?timeout: Numeric?) -> nil
+    def delete: (space_ref space, key key, ?index: index_ref, ?as: shape, ?timeout: Numeric?) -> row?
+    def delete_by: (space_ref space, key key, index: index_ref, ?iterator: iterator, ?batch_size: Integer,
+                    ?timeout: Numeric?) -> Integer
+    def call: (String function_name, ?Array[untyped] arguments, ?timeout: Numeric?,
+               ?on_push: (^(untyped message) -> void)?) -> Array[untyped]
+    def eval: (String expression, ?Array[untyped] arguments, ?timeout: Numeric?) -> Array[untyped]
+    def execute: (String | Integer | PreparedStatement sql, ?Array[untyped] bindings, ?timeout: Numeric?) -> SqlResult
+    def prepare: (String sql, ?timeout: Numeric?) -> PreparedStatement
+
+    def server_version: () -> String
+    def connected?: () -> bool
+    def transaction: [T] (?isolation: isolation, ?timeout: Numeric?) { (Stream) -> T } -> T
+    def watch: (String key) { (String key, untyped value) -> void } -> Watcher
+    def close: () -> void
+    def inspect: () -> String
+  end
+end

data/sig/tarantool/errors.rbs

@@ -0,0 +1,47 @@
+module Tarantool
+  # Base class for every error raised by the tarantool-* gems.
+  class Error < StandardError
+    # Rows delete_by confirmed deleted before it failed; nil for any other operation.
+    attr_accessor deleted: Integer?
+  end
+
+  class ConnectionError < Error
+  end
+
+  class ClientClosedError < ConnectionError
+  end
+
+  class TimeoutError < Error
+  end
+
+  class AuthenticationError < Error
+    attr_reader code: Integer?
+
+    def initialize: (?String? message, ?code: Integer?) -> void
+  end
+
+  class ProtocolError < Error
+  end
+
+  class SchemaError < Error
+  end
+
+  class UnknownFieldError < ArgumentError
+  end
+
+  class TransactionError < Error
+  end
+
+  class NoAvailableInstanceError < Error
+  end
+
+  class ServerError < Error
+    attr_reader code: Integer
+    # The box.error stack as sent: one Hash per error (keys :type, :file, :line, :message, :errno, :code,
+    # :fields); the constructor takes whatever Array it is given.
+    attr_reader error_stack: Array[untyped]
+    attr_reader schema_version: Integer?
+
+    def initialize: (String? message, code: Integer, ?error_stack: Array[untyped], ?schema_version: Integer?) -> void
+  end
+end

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: tarantool-client
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Starlexxx
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-17 00:00:00.000000000 Z
+date: 2026-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement
@@ -132,6 +138,11 @@ files:
 - lib/tarantool/client/watcher.rb
 - lib/tarantool/client/watchers.rb
 - lib/tarantool/client/watchers/dispatcher.rb
+- sig/tarantool/client.rbs
+- sig/tarantool/client/pool.rbs
+- sig/tarantool/client/stream.rbs
+- sig/tarantool/client/values.rbs
+- sig/tarantool/errors.rbs
 homepage: https://github.com/Starlexxx/tarantool-ruby
 licenses:
 - MIT