statelydb 0.18.3 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e07b296b0a2f8dda95a010bd074b91c653f8a5c45cf2a6fc0418d7b158644ca8
-  data.tar.gz: cf3895a85a5090c62c87bda2d2bf75d0d6ae7a668c1f8dfb5bb2e4068399fdeb
+  metadata.gz: f2596e8fefad5c493ca74719bd8d88366196aa67060aa8bf7f235426b4042b76
+  data.tar.gz: 9a01f05434b629b8d7056fa9bf24b1e310d9377b8d853779a5a2402939ecb598
 SHA512:
-  metadata.gz: 0644d032470017c1a692713fd1a9f06633e836af51c59a20bf4859c21d94e67031c58db6fa70e72ef5055594eb305cad2b961cd4437c280d8147d7ed9e8aefea
-  data.tar.gz: 64d33d0c37809b0a819014ea38cba6ec506d313a163e09286dbd20944291d9d49f34cfc21d042f80a85aeb2050bccc72d8b843061bbae5dc63e882b09802ca41
+  metadata.gz: d071adf0dba8e6981ec77346b80502a69c2424a9a165c55acbbacba62ca424df341efa5e36215294da76595666371c90c0575046d78eb4527039a6b75d4499dd
+  data.tar.gz: 0eda4f14edcf95b3f317e5b82a70b86e5502ac2c970a6940c592f5d3bfd0b1e93ab0d302de94bb47091d71b709f411576928a9e9ac50727e423e91083108688e

data/lib/common/auth/auth_token_provider.rb

@@ -41,6 +41,7 @@ module StatelyDB
 
         # Close the token provider and kill any background operations
         # This just invokes the close method on the actor which should do the cleanup
+        # @return [void]
         def close
           @actor.close
         end
@@ -81,6 +82,7 @@ module StatelyDB
 
           # Initialize the actor. This runs on the actor thread which means
           # we can dispatch async operations here.
+          # @return [void]
           def init
             # disable the async lib logger. We do our own error handling and propagation
             Console.logger.disable(Async::Task)
@@ -88,6 +90,7 @@ module StatelyDB
           end
 
           # Close the token provider and kill any background operations
+          # @return [void]
           def close
             @scheduled&.stop
             @token_fetcher&.close
@@ -117,7 +120,7 @@ module StatelyDB
           end
 
           # Refresh the access token
-          # @return [Task] A task that will resolve to the new access token
+          # @return [::Async::Task] A task that will resolve to the new access token
           def refresh_token
             Async do
               # we use an Async::Condition to dedupe multiple requests here
@@ -187,6 +190,11 @@ module StatelyDB
         end
 
         # Persistent state for the token provider
+        #
+        # @!attribute [r] token
+        #   @return [String] The token string.
+        # @!attribute [r] expires_at_unix_secs
+        #   @return [Integer] The expiration time in unix seconds.
         class TokenState
           attr_reader :token, :expires_at_unix_secs
 

data/lib/common/auth/interceptor.rb

@@ -20,7 +20,7 @@ module StatelyDB
         # gRPC client unary interceptor
         #
         # @param [Object] request The request object
-        # @param [GRPC::ActiveCall] call The active call object
+        # @param [::GRPC::ActiveCall] call The active call object
         # @param [Symbol] method The method being called
         # @param [Hash] metadata The metadata hash
         # @return [Object] The response object
@@ -33,7 +33,7 @@ module StatelyDB
         # gRPC client streaming interceptor
         #
         # @param [Enumerable] requests The list of requests
-        # @param [GRPC::ActiveCall] call The active call object
+        # @param [::GRPC::ActiveCall] call The active call object
         # @param [Symbol] method The method being called
         # @param [Hash] metadata The metadata hash
         # @return [Enumerator] The response enumerator
@@ -46,7 +46,7 @@ module StatelyDB
         # gRPC  server streaming interceptor
         #
         # @param [Object] request The request object
-        # @param [GRPC::ActiveCall] call The active call object
+        # @param [::GRPC::ActiveCall] call The active call object
         # @param [Symbol] method The method being called
         # @param [Hash] metadata The metadata hash
         # @return [Enumerator] The response enumerator
@@ -59,7 +59,7 @@ module StatelyDB
         # gRPC bidirectional streaming interceptor
         #
         # @param [Enumerable] requests The list of requests
-        # @param [GRPC::ActiveCall] call The active call object
+        # @param [::GRPC::ActiveCall] call The active call object
         # @param [Symbol] method The method being called
         # @param [Hash] metadata The metadata hash
         # @return [Enumerator] The response enumerator

data/lib/common/auth/token_fetcher.rb

@@ -10,6 +10,11 @@ module StatelyDB
     # A module for Stately Cloud auth code
     module Auth
       # Result from a token fetch operation
+      #
+      # @!attribute [r] token
+      #   @return [String] The token string.
+      # @!attribute [r] expires_in_secs
+      #   @return [Integer] The expiration time in seconds.
       class TokenResult
         attr_reader :token, :expires_in_secs
 
@@ -32,6 +37,7 @@ module StatelyDB
         end
 
         # Close the token provider and kill any background operations
+        # @return [void]
         def close
           raise "Not Implemented"
         end
@@ -39,6 +45,9 @@ module StatelyDB
 
       # StatelyAccessTokenFetcher is a TokenFetcher that fetches tokens from the StatelyDB API
       class StatelyAccessTokenFetcher < TokenFetcher
+        # Non-retryable errors that will not be retried.
+        #
+        # @return [Array<::GRPC::Core::StatusCodes>]
         NON_RETRYABLE_ERRORS = [
           GRPC::Core::StatusCodes::UNAUTHENTICATED,
           GRPC::Core::StatusCodes::PERMISSION_DENIED,
@@ -46,6 +55,10 @@ module StatelyDB
           GRPC::Core::StatusCodes::UNIMPLEMENTED,
           GRPC::Core::StatusCodes::INVALID_ARGUMENT
         ].freeze
+
+        # Number of retry attempts for requests.
+        #
+        # @return [Integer]
         RETRY_ATTEMPTS = 10
 
         # @param [String] endpoint The endpoint of the OAuth server
@@ -76,6 +89,8 @@ module StatelyDB
           end
         end
 
+        # Close the token provider and kill any background operations
+        # @return [void]
         def close
           @channel&.close
         end

data/lib/common/auth/token_provider.rb

@@ -15,6 +15,7 @@ module StatelyDB
         end
 
         # Close the token provider and kill any background operations
+        # @return [void]
         def close
           raise "Not Implemented"
         end

data/lib/common/net/conn.rb

@@ -9,7 +9,7 @@ module StatelyDB
     module Net
       # Create a new gRPC channel
       # @param [String] endpoint The endpoint to connect to
-      # @return [GRPC::Core::Channel] The new channel
+      # @return [::GRPC::Core::Channel] The new channel
       def self.new_channel(endpoint:)
         endpoint_uri = URI(endpoint)
         creds = GRPC::Core::ChannelCredentials.new

data/lib/key_path.rb

@@ -9,8 +9,8 @@ module StatelyDB
     end
 
     # Appends a new path segment.
-    # @param [String] namespace
-    # @param [String, StatelyDB::UUID, #to_s] identifier
+    # @param namespace [String]
+    # @param identifier [String, StatelyDB::UUID, #to_s]
     # @return [KeyPath]
     def with(namespace, identifier = nil)
       if identifier.nil?
@@ -37,8 +37,8 @@ module StatelyDB
     end
 
     # Appends a new path segment.
-    # @param [String] namespace
-    # @param [String, StatelyDB::UUID, #to_s] identifier
+    # @param namespace [String]
+    # @param identifier [String, StatelyDB::UUID, #to_s]
     # @return [KeyPath]
     #
     # @example
@@ -49,7 +49,7 @@ module StatelyDB
 
     # If the value is a binary string, encode it as a url-safe base64 string with padding removed.
     #
-    # @param [String, StatelyDB::UUID, #to_s] value The value to convert to a key id.
+    # @param value [String, StatelyDB::UUID, #to_s] The value to convert to a key id.
     # @return [String]
     def self.to_key_id(value)
       if value.is_a?(StatelyDB::UUID)

data/lib/stately_codes.rb

@@ -6,6 +6,7 @@ module StatelyCode
   #
   # - Retryable
   #     This error is immediately retryable.
+  # @return [String]
   CACHED_SCHEMA_TOO_OLD = "CachedSchemaTooOld"
 
   # ConcurrentModification indicates the current transaction was aborted
@@ -34,6 +35,7 @@ module StatelyCode
   #
   # - Retryable
   #     This error is immediately retryable.
+  # @return [String]
   CONCURRENT_MODIFICATION = "ConcurrentModification"
 
   # ConditionalCheckFailed indicates that conditions provided to perform an
@@ -45,6 +47,7 @@ module StatelyCode
   # - Not Retryable
   #     Typically a conditional check failure is not retryable
   #     unless the conditions for the operation are changed.
+  # @return [String]
   CONDITIONAL_CHECK_FAILED = "ConditionalCheckFailed"
 
   # ItemReusedWithDifferentKeyPath occurs when a client reads an Item, then
@@ -57,6 +60,7 @@ module StatelyCode
   # new instance of the Item rather than reusing the read result.
   #
   # - Not Retryable
+  # @return [String]
   ITEM_REUSED_WITH_DIFFERENT_KEY_PATH = "ItemReusedWithDifferentKeyPath"
 
   # NonRecoverableTransaction indicates that conditions required for the
@@ -68,6 +72,7 @@ module StatelyCode
   # independent records with aliases pointing to the same item.
   #
   # - Not Retryable
+  # @return [String]
   NON_RECOVERABLE_TRANSACTION = "NonRecoverableTransaction"
 
   # StoreInUse indicates that the underlying Store is currently in being
@@ -76,6 +81,7 @@ module StatelyCode
   #
   # - Retryable
   #     This can be retried with backoff.
+  # @return [String]
   STORE_IN_USE = "StoreInUse"
 
   # StoreRequestLimitExceeded indicates that an attempt to modify a Store has
@@ -85,6 +91,7 @@ module StatelyCode
   # please contact support.
   #
   # - Retryable
+  # @return [String]
   STORE_REQUEST_LIMIT_EXCEEDED = "StoreRequestLimitExceeded"
 
   # StoreThroughputExceeded indicates that the underlying Store does not have
@@ -94,5 +101,6 @@ module StatelyCode
   #
   # - Retryable
   #     With an exponential backoff.
+  # @return [String]
   STORE_THROUGHPUT_EXCEEDED = "StoreThroughputExceeded"
 end

data/lib/statelydb.rb

@@ -165,6 +165,66 @@ module StatelyDB
       process_list_response(resp)
     end
 
+    # Initiates a scan request which will scan over the entire store and apply
+    # the provided filters. This API returns a token that you can pass to
+    # continue_scan to paginate through the result set. This can fail if the
+    # caller does not have permission to read Items.
+    #
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER
+    # OF ITEMS.
+    #
+    # @param limit [Integer] the maximum number of items to return
+    # @param item_types [Array<Class, String>] the item types to filter by. The returned
+    #   items will be instances of one of these types.
+    # @param total_segments [Integer] the total number of segments to divide the
+    #   scan into. Use this when you want to parallelize your operation.
+    # @param segment_index [Integer] the index of the segment to scan.
+    #   Use this when you want to parallelize your operation.
+    # @return [Array<StatelyDB::Item>, StatelyDB::Token] the list of Items and the token
+    #
+    # @example
+    #   client.data.begin_scan(limit: 10, item_types: [MyItem])
+    def begin_scan(limit: 100,
+                   item_types: [],
+                   total_segments: nil,
+                   segment_index: nil)
+      if total_segments.nil? != segment_index.nil?
+        raise StatelyDB::Error.new("total_segments and segment_index must both be set or both be nil",
+                                   code: GRPC::Core::StatusCodes::INVALID_ARGUMENT,
+                                   stately_code: "InvalidArgument")
+      end
+      req = Stately::Db::BeginScanRequest.new(
+        store_id: @store_id,
+        limit:,
+        filter_condition: item_types.map do |item_type|
+          Stately::Db::FilterCondition.new(item_type: item_type.respond_to?(:name) ? item_type.name.split("::").last : item_type)
+        end,
+        schema_version_id: @schema::SCHEMA_VERSION_ID
+      )
+      resp = @stub.begin_scan(req)
+      process_list_response(resp)
+    end
+
+    # continue_scan takes the token from a begin_scan call and returns more results
+    # based on the original request parameters and pagination options.
+    #
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER OF ITEMS.
+    #
+    # @param token [StatelyDB::Token] the token to continue from
+    # @return [Array<StatelyDB::Item>, StatelyDB::Token] the list of Items and the token
+    #
+    # @example
+    #  (items, token) = client.data.begin_scan(limit: 10, item_types: [MyItem])
+    #  client.data.continue_scan(token)
+    def continue_scan(token)
+      req = Stately::Db::ContinueScanRequest.new(
+        token_data: token.token_data,
+        schema_version_id: @schema::SCHEMA_VERSION_ID
+      )
+      resp = @stub.continue_scan(req)
+      process_list_response(resp)
+    end
+
     # Sync a list of Items from a StatelyDB Store.
     #
     # @param token [StatelyDB::Token] the token to sync from
@@ -309,7 +369,7 @@ module StatelyDB
     # then the default endpoint will be returned.
     #
     # @param endpoint [String] the endpoint to connect to
-    # @param region [Region] the region to connect to
+    # @param region [String] the region to connect to
     # @return [String] the constructed endpoint
     def self.make_endpoint(endpoint: nil, region: nil)
       return endpoint unless endpoint.nil?
@@ -324,7 +384,7 @@ module StatelyDB
 
     # Process a list response from begin_list or continue_list
     #
-    # @param resp [Stately::Db::ListResponse] the response to process
+    # @param resp [::Stately::Db::ListResponse] the response to process
     # @return [(Array<StatelyDB::Item>, StatelyDB::Token)] the list of Items and the token
     # @api private
     # @!visibility private
@@ -350,7 +410,7 @@ module StatelyDB
 
     # Process a sync response from sync_list
     #
-    # @param resp [Stately::Db::SyncResponse] the response to process
+    # @param resp [::Stately::Db::SyncResponse] the response to process
     # @return [StatelyDB::SyncResult] the result of the sync operation
     # @api private
     # @!visibility private

data/lib/transaction/transaction.rb

@@ -42,9 +42,9 @@ module StatelyDB
 
       # Initialize a new Transaction
       #
-      # @param stub [Stately::Db::DatabaseService::Stub] a StatelyDB gRPC stub
+      # @param stub [::Stately::Db::DatabaseService::Stub] a StatelyDB gRPC stub
       # @param store_id [Integer] the StatelyDB Store to transact against
-      # @param schema [StatelyDB::Schema] the schema to use for marshalling and unmarshalling Items
+      # @param schema [::StatelyDB::Schema] the schema to use for marshalling and unmarshalling Items
       def initialize(stub:, store_id:, schema:)
         @stub = stub
         @store_id = store_id
@@ -57,8 +57,8 @@ module StatelyDB
 
       # Send a request and wait for a response
       #
-      # @param req [Stately::Db::TransactionRequest] the request to send
-      # @return [Stately::Db::TransactionResponse] the response
+      # @param req [::Stately::Db::TransactionRequest] the request to send
+      # @return [::Stately::Db::TransactionResponse] the response
       # @api private
       # @!visibility private
       def request_response(req)
@@ -78,7 +78,7 @@ module StatelyDB
 
       # Send a request and don't wait for a response
       #
-      # @param req [Stately::Db::TransactionRequest] the request to send
+      # @param req [::Stately::Db::TransactionRequest] the request to send
       # @return [void] nil
       # @api private
       # @!visibility private
@@ -91,9 +91,9 @@ module StatelyDB
       # Send a request and process all responses, until we receive a finished message. This is used for list operations.
       # Each response is processed by the block passed to this method, and the response for this method is a token.
       #
-      # @param req [Stately::Db::TransactionRequest] the request to send
-      # @yieldparam resp [Stately::Db::TransactionListResponse] the response
-      # @return [Stately::Db::ListToken] the token
+      # @param req [::Stately::Db::TransactionRequest] the request to send
+      # @yieldparam resp [::Stately::Db::TransactionListResponse] the response
+      # @return [::Stately::Db::ListToken] the token
       # @example
       #   request_list_responses(req) do |resp|
       #     resp.result.items.each do |result|
@@ -153,7 +153,7 @@ module StatelyDB
       end
 
       # Abort a transaction. Abort is called implicitly if an exception is raised within the block passed to transaction.
-      # @return [Stately::Db::TransactionResponse]
+      # @return [::Stately::Db::TransactionResponse]
       # @api private
       # @!visibility private
       def abort
@@ -333,7 +333,7 @@ module StatelyDB
       # @param limit [Integer] the maximum number of items to return
       # @param sort_property [String] the property to sort by
       # @param sort_direction [Symbol] the direction to sort by (:ascending or :descending)
-      # @return [(Array<StatelyDB::Item>, Stately::Db::ListToken)] the list of Items and the token
+      # @return [(Array<StatelyDB::Item>, ::Stately::Db::ListToken)] the list of Items and the token
       #
       # Example:
       #   client.data.transaction do |txn|
@@ -363,9 +363,9 @@ module StatelyDB
 
       # Continue listing Items from a StatelyDB Store using a token.
       #
-      # @param token [Stately::Db::ListToken] the token to continue from
+      # @param token [::Stately::Db::ListToken] the token to continue from
       # @param continue_direction [Symbol] the direction to continue by (:forward or :backward)
-      # @return [(Array<StatelyDB::Item>, Stately::Db::ListToken)] the list of Items and the token
+      # @return [(Array<StatelyDB::Item>, ::Stately::Db::ListToken)] the list of Items and the token
       #
       # Example:
       #   client.data.transaction do |txn|
@@ -388,8 +388,8 @@ module StatelyDB
 
       # Processes a list response from begin_list or continue_list
       #
-      # @param req [Stately::Db::TransactionRequest] the request to send
-      # @return [(Array<StatelyDB::Item>, Stately::Db::ListToken)] the list of Items and the token
+      # @param req [::Stately::Db::TransactionRequest] the request to send
+      # @return [(Array<StatelyDB::Item>, ::Stately::Db::ListToken)] the list of Items and the token
       # @api private
       # @!visibility private
       def do_list_request_response(req)
@@ -405,7 +405,7 @@ module StatelyDB
       # We are using a oneof inside the TransactionRequest to determine the type of request. The ruby
       # generated code does not have a helper for the internal request type so we need to infer it.
       #
-      # @param req [Stately::Db::TransactionRequest] the request
+      # @param req [::Stately::Db::TransactionRequest] the request
       # @return [Class] the response type
       # @api private
       # @!visibility private
@@ -422,7 +422,7 @@ module StatelyDB
       # We are using a oneof inside the TransactionResponse to determine the type of response. The ruby
       # generated code does not have a helper for the internal response type so we need to infer it.
       #
-      # @param resp [Stately::Db::TransactionResponse] the response
+      # @param resp [::Stately::Db::TransactionResponse] the response
       # @return [Class] the response type
       # @api private
       # @!visibility private

data/{sig → rbi}/statelydb.rbi

@@ -297,6 +297,53 @@ module StatelyDB
     sig { params(token: StatelyDB::Token).returns(T.any(T::Array[StatelyDB::Item], StatelyDB::Token)) }
     def continue_list(token); end
 
+    # Initiates a scan request which will scan over the entire store and apply
+    # the provided filters. This API returns a token that you can pass to
+    # continue_scan to paginate through the result set. This can fail if the
+    # caller does not have permission to read Items.
+    # 
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER
+    # OF ITEMS.
+    # 
+    # _@param_ `limit` — the maximum number of items to return
+    # 
+    # _@param_ `item_types` — the item types to filter by. The returned items will be instances of one of these types.
+    # 
+    # _@param_ `total_segments` — the total number of segments to divide the scan into. Use this when you want to parallelize your operation.
+    # 
+    # _@param_ `segment_index` — the index of the segment to scan. Use this when you want to parallelize your operation.
+    # 
+    # _@return_ — the list of Items and the token
+    # 
+    # ```ruby
+    # client.data.begin_scan(limit: 10, item_types: [MyItem])
+    # ```
+    sig do
+      params(
+        limit: Integer,
+        item_types: T::Array[T.any(Class, String)],
+        total_segments: T.nilable(Integer),
+        segment_index: T.nilable(Integer)
+      ).returns(T.any(T::Array[StatelyDB::Item], StatelyDB::Token))
+    end
+    def begin_scan(limit: 100, item_types: [], total_segments: nil, segment_index: nil); end
+
+    # continue_scan takes the token from a begin_scan call and returns more results
+    # based on the original request parameters and pagination options.
+    # 
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER OF ITEMS.
+    # 
+    # _@param_ `token` — the token to continue from
+    # 
+    # _@return_ — the list of Items and the token
+    # 
+    # ```ruby
+    # (items, token) = client.data.begin_scan(limit: 10, item_types: [MyItem])
+    # client.data.continue_scan(token)
+    # ```
+    sig { params(token: StatelyDB::Token).returns(T.any(T::Array[StatelyDB::Item], StatelyDB::Token)) }
+    def continue_scan(token); end
+
     # Sync a list of Items from a StatelyDB Store.
     # 
     # _@param_ `token` — the token to sync from
@@ -387,7 +434,7 @@ module StatelyDB
     # _@param_ `region` — the region to connect to
     # 
     # _@return_ — the constructed endpoint
-    sig { params(endpoint: T.nilable(String), region: T.nilable(Region)).returns(String) }
+    sig { params(endpoint: T.nilable(String), region: T.nilable(String)).returns(String) }
     def self.make_endpoint(endpoint: nil, region: nil); end
 
     # Process a list response from begin_list or continue_list
@@ -395,7 +442,7 @@ module StatelyDB
     # _@param_ `resp` — the response to process
     # 
     # _@return_ — the list of Items and the token
-    sig { params(resp: Stately::Db::ListResponse).returns([T::Array[StatelyDB::Item], StatelyDB::Token]) }
+    sig { params(resp: ::Stately::Db::ListResponse).returns([T::Array[StatelyDB::Item], StatelyDB::Token]) }
     def process_list_response(resp); end
 
     # Process a sync response from sync_list
@@ -403,7 +450,7 @@ module StatelyDB
     # _@param_ `resp` — the response to process
     # 
     # _@return_ — the result of the sync operation
-    sig { params(resp: Stately::Db::SyncResponse).returns(StatelyDB::SyncResult) }
+    sig { params(resp: ::Stately::Db::SyncResponse).returns(StatelyDB::SyncResult) }
     def process_sync_response(resp); end
   end
 
@@ -474,7 +521,7 @@ module StatelyDB
       # _@param_ `endpoint` — The endpoint to connect to
       # 
       # _@return_ — The new channel
-      sig { params(endpoint: String).returns(GRPC::Core::Channel) }
+      sig { params(endpoint: String).returns(::GRPC::Core::Channel) }
       def self.new_channel(endpoint:); end
     end
 
@@ -500,7 +547,7 @@ module StatelyDB
         sig do
           params(
             request: Object,
-            call: GRPC::ActiveCall,
+            call: ::GRPC::ActiveCall,
             method: Symbol,
             metadata: T::Hash[T.untyped, T.untyped]
           ).returns(Object)
@@ -521,7 +568,7 @@ module StatelyDB
         sig do
           params(
             requests: T::Enumerable[T.untyped],
-            call: GRPC::ActiveCall,
+            call: ::GRPC::ActiveCall,
             method: Symbol,
             metadata: T::Hash[T.untyped, T.untyped]
           ).returns(T::Enumerator[T.untyped])
@@ -542,7 +589,7 @@ module StatelyDB
         sig do
           params(
             request: Object,
-            call: GRPC::ActiveCall,
+            call: ::GRPC::ActiveCall,
             method: Symbol,
             metadata: T::Hash[T.untyped, T.untyped]
           ).returns(T::Enumerator[T.untyped])
@@ -563,7 +610,7 @@ module StatelyDB
         sig do
           params(
             requests: T::Enumerable[T.untyped],
-            call: GRPC::ActiveCall,
+            call: ::GRPC::ActiveCall,
             method: Symbol,
             metadata: T::Hash[T.untyped, T.untyped]
           ).returns(T::Enumerator[T.untyped])
@@ -578,6 +625,11 @@ module StatelyDB
       end
 
       # Result from a token fetch operation
+      # 
+      # @!attribute [r] token
+      #   @return [String] The token string.
+      # @!attribute [r] expires_in_secs
+      #   @return [Integer] The expiration time in seconds.
       class TokenResult
         # Create a new TokenResult
         # 
@@ -587,12 +639,12 @@ module StatelyDB
         sig { params(token: String, expires_in_secs: Integer).void }
         def initialize(token:, expires_in_secs:); end
 
-        # Returns the value of attribute token.
-        sig { returns(T.untyped) }
+        # _@return_ — The token string.
+        sig { returns(String) }
         attr_reader :token
 
-        # Returns the value of attribute expires_in_secs.
-        sig { returns(T.untyped) }
+        # _@return_ — The expiration time in seconds.
+        sig { returns(Integer) }
         attr_reader :expires_in_secs
       end
 
@@ -606,7 +658,7 @@ module StatelyDB
         def fetch; end
 
         # Close the token provider and kill any background operations
-        sig { returns(T.untyped) }
+        sig { void }
         def close; end
       end
 
@@ -635,7 +687,8 @@ module StatelyDB
         sig { returns(TokenResult) }
         def fetch; end
 
-        sig { returns(T.untyped) }
+        # Close the token provider and kill any background operations
+        sig { void }
         def close; end
 
         # Check if an error is retryable
@@ -659,7 +712,7 @@ module StatelyDB
         def get_token(force: false); end
 
         # Close the token provider and kill any background operations
-        sig { returns(T.untyped) }
+        sig { void }
         def close; end
       end
 
@@ -678,7 +731,7 @@ module StatelyDB
 
         # Close the token provider and kill any background operations
         # This just invokes the close method on the actor which should do the cleanup
-        sig { returns(T.untyped) }
+        sig { void }
         def close; end
 
         # Get the current access token
@@ -700,11 +753,11 @@ module StatelyDB
 
           # Initialize the actor. This runs on the actor thread which means
           # we can dispatch async operations here.
-          sig { returns(T.untyped) }
+          sig { void }
           def init; end
 
           # Close the token provider and kill any background operations
-          sig { returns(T.untyped) }
+          sig { void }
           def close; end
 
           # Get the current access token
@@ -724,7 +777,7 @@ module StatelyDB
           # Refresh the access token
           # 
           # _@return_ — A task that will resolve to the new access token
-          sig { returns(Task) }
+          sig { returns(::Async::Task) }
           def refresh_token; end
 
           # Refresh the access token implementation
@@ -735,6 +788,11 @@ module StatelyDB
         end
 
         # Persistent state for the token provider
+        # 
+        # @!attribute [r] token
+        #   @return [String] The token string.
+        # @!attribute [r] expires_at_unix_secs
+        #   @return [Integer] The expiration time in unix seconds.
         class TokenState
           # Create a new TokenState
           # 
@@ -744,12 +802,12 @@ module StatelyDB
           sig { params(token: String, expires_at_unix_secs: Integer).void }
           def initialize(token:, expires_at_unix_secs:); end
 
-          # Returns the value of attribute token.
-          sig { returns(T.untyped) }
+          # _@return_ — The token string.
+          sig { returns(String) }
           attr_reader :token
 
-          # Returns the value of attribute expires_at_unix_secs.
-          sig { returns(T.untyped) }
+          # _@return_ — The expiration time in unix seconds.
+          sig { returns(Integer) }
           attr_reader :expires_at_unix_secs
         end
       end
@@ -805,7 +863,7 @@ module StatelyDB
       # _@param_ `store_id` — the StatelyDB Store to transact against
       # 
       # _@param_ `schema` — the schema to use for marshalling and unmarshalling Items
-      sig { params(stub: Stately::Db::DatabaseService::Stub, store_id: Integer, schema: StatelyDB::Schema).void }
+      sig { params(stub: ::Stately::Db::DatabaseService::Stub, store_id: Integer, schema: ::StatelyDB::Schema).void }
       def initialize(stub:, store_id:, schema:); end
 
       # Send a request and wait for a response
@@ -813,7 +871,7 @@ module StatelyDB
       # _@param_ `req` — the request to send
       # 
       # _@return_ — the response
-      sig { params(req: Stately::Db::TransactionRequest).returns(Stately::Db::TransactionResponse) }
+      sig { params(req: ::Stately::Db::TransactionRequest).returns(::Stately::Db::TransactionResponse) }
       def request_response(req); end
 
       # Send a request and don't wait for a response
@@ -821,7 +879,7 @@ module StatelyDB
       # _@param_ `req` — the request to send
       # 
       # _@return_ — nil
-      sig { params(req: Stately::Db::TransactionRequest).void }
+      sig { params(req: ::Stately::Db::TransactionRequest).void }
       def request_only(req); end
 
       # Send a request and process all responses, until we receive a finished message. This is used for list operations.
@@ -837,7 +895,7 @@ module StatelyDB
       #     puts result.item.key_path
       #   end
       # ```
-      sig { params(req: Stately::Db::TransactionRequest, blk: T.proc.params(resp: Stately::Db::TransactionListResponse).void).returns(Stately::Db::ListToken) }
+      sig { params(req: ::Stately::Db::TransactionRequest, blk: T.proc.params(resp: ::Stately::Db::TransactionListResponse).void).returns(::Stately::Db::ListToken) }
       def request_list_responses(req, &blk); end
 
       # Begin a transaction. Begin is called implicitly when the block passed to transaction is called.
@@ -851,7 +909,7 @@ module StatelyDB
       def commit; end
 
       # Abort a transaction. Abort is called implicitly if an exception is raised within the block passed to transaction.
-      sig { returns(Stately::Db::TransactionResponse) }
+      sig { returns(::Stately::Db::TransactionResponse) }
       def abort; end
 
       # Check if a transaction is open. A transaction is open if begin has been called and commit or abort has not been called.
@@ -974,7 +1032,7 @@ module StatelyDB
           limit: Integer,
           sort_property: T.nilable(String),
           sort_direction: Symbol
-        ).returns([T::Array[StatelyDB::Item], Stately::Db::ListToken])
+        ).returns([T::Array[StatelyDB::Item], ::Stately::Db::ListToken])
       end
       def begin_list(prefix, limit: 100, sort_property: nil, sort_direction: :ascending); end
 
@@ -991,7 +1049,7 @@ module StatelyDB
       # _@param_ `continue_direction` — the direction to continue by (:forward or :backward)
       # 
       # _@return_ — the list of Items and the token
-      sig { params(token: Stately::Db::ListToken, continue_direction: Symbol).returns([T::Array[StatelyDB::Item], Stately::Db::ListToken]) }
+      sig { params(token: ::Stately::Db::ListToken, continue_direction: Symbol).returns([T::Array[StatelyDB::Item], ::Stately::Db::ListToken]) }
       def continue_list(token, continue_direction: :forward); end
 
       # Processes a list response from begin_list or continue_list
@@ -999,7 +1057,7 @@ module StatelyDB
       # _@param_ `req` — the request to send
       # 
       # _@return_ — the list of Items and the token
-      sig { params(req: Stately::Db::TransactionRequest).returns([T::Array[StatelyDB::Item], Stately::Db::ListToken]) }
+      sig { params(req: ::Stately::Db::TransactionRequest).returns([T::Array[StatelyDB::Item], ::Stately::Db::ListToken]) }
       def do_list_request_response(req); end
 
       # We are using a oneof inside the TransactionRequest to determine the type of request. The ruby
@@ -1008,7 +1066,7 @@ module StatelyDB
       # _@param_ `req` — the request
       # 
       # _@return_ — the response type
-      sig { params(req: Stately::Db::TransactionRequest).returns(Class) }
+      sig { params(req: ::Stately::Db::TransactionRequest).returns(Class) }
       def infer_response_type_from_request(req); end
 
       # We are using a oneof inside the TransactionResponse to determine the type of response. The ruby
@@ -1017,7 +1075,7 @@ module StatelyDB
       # _@param_ `resp` — the response
       # 
       # _@return_ — the response type
-      sig { params(resp: Stately::Db::TransactionResponse).returns(Class) }
+      sig { params(resp: ::Stately::Db::TransactionResponse).returns(Class) }
       def infer_response_type_from_response(resp); end
 
       # Result represents the results of a transaction

data/sig/statelydb.rbs

@@ -252,6 +252,49 @@ module StatelyDB
     # ```
     def continue_list: (StatelyDB::Token token) -> (::Array[StatelyDB::Item] | StatelyDB::Token)
 
+    # Initiates a scan request which will scan over the entire store and apply
+    # the provided filters. This API returns a token that you can pass to
+    # continue_scan to paginate through the result set. This can fail if the
+    # caller does not have permission to read Items.
+    # 
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER
+    # OF ITEMS.
+    # 
+    # _@param_ `limit` — the maximum number of items to return
+    # 
+    # _@param_ `item_types` — the item types to filter by. The returned items will be instances of one of these types.
+    # 
+    # _@param_ `total_segments` — the total number of segments to divide the scan into. Use this when you want to parallelize your operation.
+    # 
+    # _@param_ `segment_index` — the index of the segment to scan. Use this when you want to parallelize your operation.
+    # 
+    # _@return_ — the list of Items and the token
+    # 
+    # ```ruby
+    # client.data.begin_scan(limit: 10, item_types: [MyItem])
+    # ```
+    def begin_scan: (
+                      ?limit: Integer,
+                      ?item_types: ::Array[(Class | String)],
+                      ?total_segments: Integer?,
+                      ?segment_index: Integer?
+                    ) -> (::Array[StatelyDB::Item] | StatelyDB::Token)
+
+    # continue_scan takes the token from a begin_scan call and returns more results
+    # based on the original request parameters and pagination options.
+    # 
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER OF ITEMS.
+    # 
+    # _@param_ `token` — the token to continue from
+    # 
+    # _@return_ — the list of Items and the token
+    # 
+    # ```ruby
+    # (items, token) = client.data.begin_scan(limit: 10, item_types: [MyItem])
+    # client.data.continue_scan(token)
+    # ```
+    def continue_scan: (StatelyDB::Token token) -> (::Array[StatelyDB::Item] | StatelyDB::Token)
+
     # Sync a list of Items from a StatelyDB Store.
     # 
     # _@param_ `token` — the token to sync from
@@ -337,21 +380,21 @@ module StatelyDB
     # _@param_ `region` — the region to connect to
     # 
     # _@return_ — the constructed endpoint
-    def self.make_endpoint: (?endpoint: String?, ?region: Region?) -> String
+    def self.make_endpoint: (?endpoint: String?, ?region: String?) -> String
 
     # Process a list response from begin_list or continue_list
     # 
     # _@param_ `resp` — the response to process
     # 
     # _@return_ — the list of Items and the token
-    def process_list_response: (Stately::Db::ListResponse resp) -> [::Array[StatelyDB::Item], StatelyDB::Token]
+    def process_list_response: (::Stately::Db::ListResponse resp) -> [::Array[StatelyDB::Item], StatelyDB::Token]
 
     # Process a sync response from sync_list
     # 
     # _@param_ `resp` — the response to process
     # 
     # _@return_ — the result of the sync operation
-    def process_sync_response: (Stately::Db::SyncResponse resp) -> StatelyDB::SyncResult
+    def process_sync_response: (::Stately::Db::SyncResponse resp) -> StatelyDB::SyncResult
   end
 
   # SyncResult represents the results of a sync operation.
@@ -413,7 +456,7 @@ module StatelyDB
       # _@param_ `endpoint` — The endpoint to connect to
       # 
       # _@return_ — The new channel
-      def self.new_channel: (endpoint: String) -> GRPC::Core::Channel
+      def self.new_channel: (endpoint: String) -> ::GRPC::Core::Channel
     end
 
     # A module for Stately Cloud auth code
@@ -436,7 +479,7 @@ module StatelyDB
         # _@return_ — The response object
         def request_response: (
                                 request: Object,
-                                call: GRPC::ActiveCall,
+                                call: ::GRPC::ActiveCall,
                                 method: Symbol,
                                 metadata: ::Hash[untyped, untyped]
                               ) -> Object
@@ -454,7 +497,7 @@ module StatelyDB
         # _@return_ — The response enumerator
         def client_streamer: (
                                requests: ::Enumerable[untyped],
-                               call: GRPC::ActiveCall,
+                               call: ::GRPC::ActiveCall,
                                method: Symbol,
                                metadata: ::Hash[untyped, untyped]
                              ) -> ::Enumerator[untyped]
@@ -472,7 +515,7 @@ module StatelyDB
         # _@return_ — The response enumerator
         def server_streamer: (
                                request: Object,
-                               call: GRPC::ActiveCall,
+                               call: ::GRPC::ActiveCall,
                                method: Symbol,
                                metadata: ::Hash[untyped, untyped]
                              ) -> ::Enumerator[untyped]
@@ -490,7 +533,7 @@ module StatelyDB
         # _@return_ — The response enumerator
         def bidi_streamer: (
                              requests: ::Enumerable[untyped],
-                             call: GRPC::ActiveCall,
+                             call: ::GRPC::ActiveCall,
                              method: Symbol,
                              metadata: ::Hash[untyped, untyped]
                            ) -> ::Enumerator[untyped]
@@ -502,6 +545,11 @@ module StatelyDB
       end
 
       # Result from a token fetch operation
+      # 
+      # @!attribute [r] token
+      #   @return [String] The token string.
+      # @!attribute [r] expires_in_secs
+      #   @return [Integer] The expiration time in seconds.
       class TokenResult
         # Create a new TokenResult
         # 
@@ -510,11 +558,11 @@ module StatelyDB
         # _@param_ `expires_in_secs` — The number of seconds until the token expires
         def initialize: (token: String, expires_in_secs: Integer) -> void
 
-        # Returns the value of attribute token.
-        attr_reader token: untyped
+        # _@return_ — The token string.
+        attr_reader token: String
 
-        # Returns the value of attribute expires_in_secs.
-        attr_reader expires_in_secs: untyped
+        # _@return_ — The expiration time in seconds.
+        attr_reader expires_in_secs: Integer
       end
 
       # TokenFetcher is an abstract base class that should be extended
@@ -526,13 +574,13 @@ module StatelyDB
         def fetch: () -> TokenResult
 
         # Close the token provider and kill any background operations
-        def close: () -> untyped
+        def close: () -> void
       end
 
       # StatelyAccessTokenFetcher is a TokenFetcher that fetches tokens from the StatelyDB API
       class StatelyAccessTokenFetcher < StatelyDB::Common::Auth::TokenFetcher
-        NON_RETRYABLE_ERRORS: untyped
-        RETRY_ATTEMPTS: untyped
+        NON_RETRYABLE_ERRORS: ::Array[::GRPC::Core::StatusCodes]
+        RETRY_ATTEMPTS: Integer
 
         # _@param_ `endpoint` — The endpoint of the OAuth server
         # 
@@ -546,7 +594,8 @@ module StatelyDB
         # _@return_ — The fetched TokenResult
         def fetch: () -> TokenResult
 
-        def close: () -> untyped
+        # Close the token provider and kill any background operations
+        def close: () -> void
 
         # Check if an error is retryable
         # 
@@ -567,7 +616,7 @@ module StatelyDB
         def get_token: (?force: bool) -> String
 
         # Close the token provider and kill any background operations
-        def close: () -> untyped
+        def close: () -> void
       end
 
       # AuthTokenProvider is an implementation of the TokenProvider abstract base class
@@ -584,7 +633,7 @@ module StatelyDB
 
         # Close the token provider and kill any background operations
         # This just invokes the close method on the actor which should do the cleanup
-        def close: () -> untyped
+        def close: () -> void
 
         # Get the current access token
         # 
@@ -603,10 +652,10 @@ module StatelyDB
 
           # Initialize the actor. This runs on the actor thread which means
           # we can dispatch async operations here.
-          def init: () -> untyped
+          def init: () -> void
 
           # Close the token provider and kill any background operations
-          def close: () -> untyped
+          def close: () -> void
 
           # Get the current access token
           # 
@@ -623,7 +672,7 @@ module StatelyDB
           # Refresh the access token
           # 
           # _@return_ — A task that will resolve to the new access token
-          def refresh_token: () -> Task
+          def refresh_token: () -> ::Async::Task
 
           # Refresh the access token implementation
           # 
@@ -632,6 +681,11 @@ module StatelyDB
         end
 
         # Persistent state for the token provider
+        # 
+        # @!attribute [r] token
+        #   @return [String] The token string.
+        # @!attribute [r] expires_at_unix_secs
+        #   @return [Integer] The expiration time in unix seconds.
         class TokenState
           # Create a new TokenState
           # 
@@ -640,11 +694,11 @@ module StatelyDB
           # _@param_ `expires_at_unix_secs` — The unix timestamp when the token expires
           def initialize: (token: String, expires_at_unix_secs: Integer) -> void
 
-          # Returns the value of attribute token.
-          attr_reader token: untyped
+          # _@return_ — The token string.
+          attr_reader token: String
 
-          # Returns the value of attribute expires_at_unix_secs.
-          attr_reader expires_at_unix_secs: untyped
+          # _@return_ — The expiration time in unix seconds.
+          attr_reader expires_at_unix_secs: Integer
         end
       end
     end
@@ -694,21 +748,21 @@ module StatelyDB
       # _@param_ `store_id` — the StatelyDB Store to transact against
       # 
       # _@param_ `schema` — the schema to use for marshalling and unmarshalling Items
-      def initialize: (stub: Stately::Db::DatabaseService::Stub, store_id: Integer, schema: StatelyDB::Schema) -> void
+      def initialize: (stub: ::Stately::Db::DatabaseService::Stub, store_id: Integer, schema: ::StatelyDB::Schema) -> void
 
       # Send a request and wait for a response
       # 
       # _@param_ `req` — the request to send
       # 
       # _@return_ — the response
-      def request_response: (Stately::Db::TransactionRequest req) -> Stately::Db::TransactionResponse
+      def request_response: (::Stately::Db::TransactionRequest req) -> ::Stately::Db::TransactionResponse
 
       # Send a request and don't wait for a response
       # 
       # _@param_ `req` — the request to send
       # 
       # _@return_ — nil
-      def request_only: (Stately::Db::TransactionRequest req) -> void
+      def request_only: (::Stately::Db::TransactionRequest req) -> void
 
       # Send a request and process all responses, until we receive a finished message. This is used for list operations.
       # Each response is processed by the block passed to this method, and the response for this method is a token.
@@ -723,7 +777,7 @@ module StatelyDB
       #     puts result.item.key_path
       #   end
       # ```
-      def request_list_responses: (Stately::Db::TransactionRequest req) ?{ (Stately::Db::TransactionListResponse resp) -> void } -> Stately::Db::ListToken
+      def request_list_responses: (::Stately::Db::TransactionRequest req) ?{ (::Stately::Db::TransactionListResponse resp) -> void } -> ::Stately::Db::ListToken
 
       # Begin a transaction. Begin is called implicitly when the block passed to transaction is called.
       # 
@@ -734,7 +788,7 @@ module StatelyDB
       def commit: () -> StatelyDB::Transaction::Transaction::Result
 
       # Abort a transaction. Abort is called implicitly if an exception is raised within the block passed to transaction.
-      def abort: () -> Stately::Db::TransactionResponse
+      def abort: () -> ::Stately::Db::TransactionResponse
 
       # Check if a transaction is open. A transaction is open if begin has been called and commit or abort has not been called.
       # 
@@ -849,7 +903,7 @@ module StatelyDB
                         ?limit: Integer,
                         ?sort_property: String?,
                         ?sort_direction: Symbol
-                      ) -> [::Array[StatelyDB::Item], Stately::Db::ListToken]
+                      ) -> [::Array[StatelyDB::Item], ::Stately::Db::ListToken]
 
       # Continue listing Items from a StatelyDB Store using a token.
       # 
@@ -864,14 +918,14 @@ module StatelyDB
       # _@param_ `continue_direction` — the direction to continue by (:forward or :backward)
       # 
       # _@return_ — the list of Items and the token
-      def continue_list: (Stately::Db::ListToken token, ?continue_direction: Symbol) -> [::Array[StatelyDB::Item], Stately::Db::ListToken]
+      def continue_list: (::Stately::Db::ListToken token, ?continue_direction: Symbol) -> [::Array[StatelyDB::Item], ::Stately::Db::ListToken]
 
       # Processes a list response from begin_list or continue_list
       # 
       # _@param_ `req` — the request to send
       # 
       # _@return_ — the list of Items and the token
-      def do_list_request_response: (Stately::Db::TransactionRequest req) -> [::Array[StatelyDB::Item], Stately::Db::ListToken]
+      def do_list_request_response: (::Stately::Db::TransactionRequest req) -> [::Array[StatelyDB::Item], ::Stately::Db::ListToken]
 
       # We are using a oneof inside the TransactionRequest to determine the type of request. The ruby
       # generated code does not have a helper for the internal request type so we need to infer it.
@@ -879,7 +933,7 @@ module StatelyDB
       # _@param_ `req` — the request
       # 
       # _@return_ — the response type
-      def infer_response_type_from_request: (Stately::Db::TransactionRequest req) -> Class
+      def infer_response_type_from_request: (::Stately::Db::TransactionRequest req) -> Class
 
       # We are using a oneof inside the TransactionResponse to determine the type of response. The ruby
       # generated code does not have a helper for the internal response type so we need to infer it.
@@ -887,7 +941,7 @@ module StatelyDB
       # _@param_ `resp` — the response
       # 
       # _@return_ — the response type
-      def infer_response_type_from_response: (Stately::Db::TransactionResponse resp) -> Class
+      def infer_response_type_from_response: (::Stately::Db::TransactionResponse resp) -> Class
 
       # Result represents the results of a transaction
       # 
@@ -993,12 +1047,12 @@ module Stately
 end
 
 module StatelyCode
-  CACHED_SCHEMA_TOO_OLD: untyped
-  CONCURRENT_MODIFICATION: untyped
-  CONDITIONAL_CHECK_FAILED: untyped
-  ITEM_REUSED_WITH_DIFFERENT_KEY_PATH: untyped
-  NON_RECOVERABLE_TRANSACTION: untyped
-  STORE_IN_USE: untyped
-  STORE_REQUEST_LIMIT_EXCEEDED: untyped
-  STORE_THROUGHPUT_EXCEEDED: untyped
+  CACHED_SCHEMA_TOO_OLD: String
+  CONCURRENT_MODIFICATION: String
+  CONDITIONAL_CHECK_FAILED: String
+  ITEM_REUSED_WITH_DIFFERENT_KEY_PATH: String
+  NON_RECOVERABLE_TRANSACTION: String
+  STORE_IN_USE: String
+  STORE_REQUEST_LIMIT_EXCEEDED: String
+  STORE_THROUGHPUT_EXCEEDED: String
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statelydb
 version: !ruby/object:Gem::Version
-  version: 0.18.3
+  version: 0.20.0
 platform: ruby
 authors:
 - Stately Cloud, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-09 00:00:00.000000000 Z
+date: 2025-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -107,8 +107,7 @@ files:
 - lib/transaction/queue.rb
 - lib/transaction/transaction.rb
 - lib/uuid.rb
-- sig/grpc.rbs
-- sig/statelydb.rbi
+- rbi/statelydb.rbi
 - sig/statelydb.rbs
 homepage: https://docs.stately.cloud/clients/ruby/
 licenses:

data/sig/grpc.rbs

@@ -1,80 +0,0 @@
-module GRPC
-  class ActiveCall
-  end
-
-  class Interceptor
-  end
-  class ClientInterceptor < Interceptor
-    # gRPC client unary interceptor
-    #
-    # _@param_ `request` — The request object
-    #
-    # _@param_ `call` — The active call object
-    #
-    # _@param_ `method` — The method being called
-    #
-    # _@param_ `metadata` — The metadata hash
-    #
-    # _@return_ — The response object
-    def request_response: (
-                            request: Object,
-                            call: GRPC::ActiveCall,
-                            method: Symbol,
-                            metadata: ::Hash[untyped, untyped]
-                          ) -> Object
-
-    # gRPC client streaming interceptor
-    #
-    # _@param_ `requests` — The list of requests
-    #
-    # _@param_ `call` — The active call object
-    #
-    # _@param_ `method` — The method being called
-    #
-    # _@param_ `metadata` — The metadata hash
-    #
-    # _@return_ — The response enumerator
-    def client_streamer: (
-                            requests: ::Enumerable[untyped],
-                            call: GRPC::ActiveCall,
-                            method: Symbol,
-                            metadata: ::Hash[untyped, untyped]
-                          ) -> ::Enumerator[untyped]
-
-    # gRPC  server streaming interceptor
-    #
-    # _@param_ `request` — The request object
-    #
-    # _@param_ `call` — The active call object
-    #
-    # _@param_ `method` — The method being called
-    #
-    # _@param_ `metadata` — The metadata hash
-    #
-    # _@return_ — The response enumerator
-    def server_streamer: (
-                            request: Object,
-                            call: GRPC::ActiveCall,
-                            method: Symbol,
-                            metadata: ::Hash[untyped, untyped]
-                          ) -> ::Enumerator[untyped]
-
-    # gRPC bidirectional streaming interceptor
-    #
-    # _@param_ `requests` — The list of requests
-    #
-    # _@param_ `call` — The active call object
-    #
-    # _@param_ `method` — The method being called
-    #
-    # _@param_ `metadata` — The metadata hash
-    #
-    # _@return_ — The response enumerator
-    def bidi_streamer: (
-                          requests: ::Enumerable[untyped],
-                          call: GRPC::ActiveCall,
-                          method: Symbol,
-                          metadata: ::Hash[untyped, untyped]
-                        ) -> ::Enumerator[untyped]
-  end
-end