statelydb 0.32.2 → 0.33.0

data/rbi/db/list_pb.rbi

@@ -12,7 +12,6 @@ class Stately::Db::BeginListRequest
       key_path_prefix: T.nilable(String),
       limit: T.nilable(Integer),
       allow_stale: T.nilable(T::Boolean),
-      sort_property: T.nilable(T.any(Symbol, String, Integer)),
       sort_direction: T.nilable(T.any(Symbol, String, Integer)),
       schema_version_id: T.nilable(Integer),
       schema_id: T.nilable(Integer),
@@ -25,7 +24,6 @@ class Stately::Db::BeginListRequest
     key_path_prefix: "",
     limit: 0,
     allow_stale: false,
-    sort_property: :SORTABLE_PROPERTY_KEY_PATH,
     sort_direction: :SORT_ASCENDING,
     schema_version_id: 0,
     schema_id: 0,
@@ -118,24 +116,6 @@ class Stately::Db::BeginListRequest
   def clear_allow_stale
   end
 
-  # sort_property is the property of the item to sort the results by. If this
-# is not set, we will sort by key path.
-  sig { returns(T.any(Symbol, Integer)) }
-  def sort_property
-  end
-
-  # sort_property is the property of the item to sort the results by. If this
-# is not set, we will sort by key path.
-  sig { params(value: T.any(Symbol, String, Integer)).void }
-  def sort_property=(value)
-  end
-
-  # sort_property is the property of the item to sort the results by. If this
-# is not set, we will sort by key path.
-  sig { void }
-  def clear_sort_property
-  end
-
   # sort_direction is the direction to sort the results in. If this is not set,
 # we will sort in ascending order.
   sig { returns(T.any(Symbol, Integer)) }

data/rbi/db/transaction_pb.rbi

@@ -617,7 +617,6 @@ class Stately::Db::TransactionBeginList
     params(
       key_path_prefix: T.nilable(String),
       limit: T.nilable(Integer),
-      sort_property: T.nilable(T.any(Symbol, String, Integer)),
       sort_direction: T.nilable(T.any(Symbol, String, Integer)),
       filter_conditions: T.nilable(T::Array[T.nilable(Stately::Db::FilterCondition)]),
       key_conditions: T.nilable(T::Array[T.nilable(Stately::Db::KeyCondition)])
@@ -626,7 +625,6 @@ class Stately::Db::TransactionBeginList
   def initialize(
     key_path_prefix: "",
     limit: 0,
-    sort_property: :SORTABLE_PROPERTY_KEY_PATH,
     sort_direction: :SORT_ASCENDING,
     filter_conditions: [],
     key_conditions: []
@@ -675,24 +673,6 @@ class Stately::Db::TransactionBeginList
   def clear_limit
   end
 
-  # sort_property is the property of the item to sort the results by. If this
-# is not set, we will sort by key path.
-  sig { returns(T.any(Symbol, Integer)) }
-  def sort_property
-  end
-
-  # sort_property is the property of the item to sort the results by. If this
-# is not set, we will sort by key path.
-  sig { params(value: T.any(Symbol, String, Integer)).void }
-  def sort_property=(value)
-  end
-
-  # sort_property is the property of the item to sort the results by. If this
-# is not set, we will sort by key path.
-  sig { void }
-  def clear_sort_property
-  end
-
   # sort_direction is the direction to sort the results in. If this is not set,
 # we will sort in ascending order.
   sig { returns(T.any(Symbol, Integer)) }

data/rbi/statelydb.rbi

@@ -223,12 +223,14 @@ module StatelyDB
     sig { void }
     def close; end
 
-    # Set whether to allow stale results for all operations with this client. This produces a new client
-    # with the allow_stale flag set.
+    # Returns a new client that is either OK with or not OK with stale reads.
+    # This affects get and list operations from the returned client. Use this
+    # only if you know you can tolerate stale reads. This can result in improved
+    # performance, availability, and cost.
     # 
-    # _@param_ `allow_stale` — whether to allow stale results
+    # _@param_ `allow_stale` — Whether staleness is allowed or not.
     # 
-    # _@return_ — a new client with the allow_stale flag set
+    # _@return_ — A clone of the existing client with allow_stale set to the new value.
     # 
     # ```ruby
     # client.with_allow_stale(true).get("/ItemType-identifier")
@@ -236,9 +238,9 @@ module StatelyDB
     sig { params(allow_stale: T::Boolean).returns(T.self_type) }
     def with_allow_stale(allow_stale); end
 
-    # Fetch a single Item from a StatelyDB Store at the given key_path.
+    # get retrieves an item by its full key path.
     # 
-    # _@param_ `key_path` — the path to the item
+    # _@param_ `key_path` — The full key path of the item.
     # 
     # _@return_ — the Item or nil if not found
     # 
@@ -248,16 +250,21 @@ module StatelyDB
     sig { params(key_path: T.any(StatelyDB::KeyPath, String)).returns(T.any(StatelyDB::Item, NilClass)) }
     def get(key_path); end
 
-    # Fetch a batch of up to 100 Items from a StatelyDB Store at the given key_paths.
+    # get_batch retrieves multiple items by their full key paths. This will
+    # return the corresponding items that exist. Use begin_list instead if you
+    # want to retrieve multiple items but don't already know the full key paths
+    # of the items you want to get. You can get items of different types in a
+    # single get_batch - you will need to check the class of each result to
+    # determine what item type it is.
     # 
-    # _@param_ `key_paths` — the paths to the items. Max 100 key paths.
+    # _@param_ `key_paths` — The full key path of each item to load.
     # 
-    # _@return_ — the items or nil if not found
+    # _@return_ — the list of items that were found.
     # 
     # ```ruby
     # client.data.get_batch("/ItemType-identifier", "/ItemType-identifier2")
     # ```
-    sig { params(key_paths: T.any(StatelyDB::KeyPath, String, T::Array[T.any(StatelyDB::KeyPath, String)])).returns(T.any(T::Array[StatelyDB::Item], NilClass)) }
+    sig { params(key_paths: T.any(StatelyDB::KeyPath, String, T::Array[T.any(StatelyDB::KeyPath, String)])).returns(T::Array[StatelyDB::Item]) }
     def get_batch(*key_paths); end
 
     # _@return_ — the list of Items and the token
@@ -269,7 +276,6 @@ module StatelyDB
       params(
         prefix: T.untyped,
         limit: T.untyped,
-        sort_property: T.untyped,
         sort_direction: T.untyped,
         item_types: T.untyped,
         cel_filters: T.untyped,
@@ -279,11 +285,26 @@ module StatelyDB
         lte: T.untyped
       ).returns(T.any(T::Array[StatelyDB::Item], StatelyDB::Token))
     end
-    def begin_list(prefix, limit: 100, sort_property: nil, sort_direction: :ascending, item_types: [], cel_filters: [], gt: nil, gte: nil, lt: nil, lte: nil); end
-
-    # Continue listing Items from a StatelyDB Store using a token.
-    # 
-    # _@param_ `token` — the token to continue from
+    def begin_list(prefix, limit: 100, sort_direction: :ascending, item_types: [], cel_filters: [], gt: nil, gte: nil, lt: nil, lte: nil); end
+
+    # continue_list takes the token from a begin_list call and returns the next
+    # "page" of results based on the original query parameters and pagination
+    # options. It doesn't have options because it is a continuation of a
+    # previous list operation. It will return a new token which can be used for
+    # another continue_list call, and so on. The token is the same one used by
+    # sync_list - each time you call either continue_list or sync_list, you
+    # should pass the latest version of the token, and the result will include a
+    # new version of the token to use in subsequent calls. You may interleave
+    # continue_list and sync_list calls however you like, but it does not make
+    # sense to make both calls in parallel. Calls to continue_list are tied to
+    # the authorization of the original begin_list call, so if the original
+    # begin_list call was allowed, continue_list with its token should also be
+    # allowed.
+    # 
+    # You can list items of different types in a single continue_list, and you
+    # can check the class of each result to handle different item types.
+    # 
+    # _@param_ `token` — The latest token from a previous list operation.
     # 
     # _@return_ — the list of Items and the token
     # 
@@ -294,13 +315,14 @@ 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.
+    # begin_scan 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.
+    # 
+    # begin_scan can return items of many types, and you can check the class of
+    # each result to handle different item types.
     # 
-    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER
-    # OF ITEMS.
+    # WARNING: THIS API CAN BE EXPENSIVE FOR STORES WITH A LARGE NUMBER OF ITEMS.
     # 
     # _@param_ `limit` — the max number of items to retrieve. If set to 0 then the first page of results will be returned which may empty because it does not contain items of your selected item types. Be sure to check token.can_continue to see if there are more results to fetch.
     # 
@@ -328,12 +350,14 @@ module StatelyDB
     end
     def begin_scan(limit: 0, item_types: [], cel_filters: [], 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.
+    # continue_scan takes the token from a begin_scan call and returns the
+    # next "page" of results based on the original query parameters and
+    # pagination options.
     # 
-    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER OF ITEMS.
+    # You can scan items of different types in a single continue_scan, and you
+    # can check the class of each result to handle different item types.
     # 
-    # _@param_ `token` — the token to continue from
+    # _@param_ `token` — the token from the previous scan operation.
     # 
     # _@return_ — the list of Items and the token
     # 
@@ -344,7 +368,39 @@ module StatelyDB
     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.
+    # sync_list returns all changes to Items within the result set of a previous
+    # List operation. For all Items within the result set that were modified, it
+    # returns the full Item at in its current state. If the result set has
+    # already been expanded to the end (in the direction of the original
+    # begin_list request), sync_list will return newly created Items as well. It
+    # also returns a list of Item key paths that were deleted since the last
+    # sync_list, which you should reconcile with your view of items returned
+    # from previous begin_list/continue_list calls. Using this API, you can
+    # start with an initial set of items from begin_list, and then stay up to
+    # date on any changes via repeated sync_list requests over time.
+    # 
+    # The token is the same one used by continue_list - each time you call
+    # either continue_list or sync_list, you should pass the latest version of
+    # the token, and then use the new token from the result in subsequent calls.
+    # You may interleave continue_list and sync_list calls however you like, but
+    # it does not make sense to make both calls in parallel. Calls to sync_list
+    # are tied to the authorization of the original begin_list call, so if the
+    # original begin_list call was allowed, sync_list with its token should also
+    # be allowed.
+    # 
+    # The result will contain:
+    #     - changed_items: Items that were changed or added since the last
+    #       sync_list call.
+    #     - deleted_item_paths: The key paths of items that were deleted since
+    #       the last sync_list call.
+    #     - updated_outside_list_window_paths: Item that were updated but
+    #       are not within the current result set. You can treat this like
+    #       deleted_item_paths, but the item hasn't actually been deleted, it's
+    #       just not part of your view of the list anymore.
+    #     - is_reset: A reset signal that indicates any previously cached
+    #       view of the result set is no longer valid. You should throw away
+    #       any locally cached data. Use the changed_items list from this result
+    #       as the new view of the result set.
     # 
     # _@param_ `token` — the token to sync from
     # 
@@ -357,15 +413,22 @@ module StatelyDB
     sig { params(token: StatelyDB::Token).returns(StatelyDB::SyncResult) }
     def sync_list(token); end
 
-    # Put an Item into a StatelyDB Store at the given key_path.
+    # put adds an Item to the Store, or replaces the Item if it already exists
+    # at that path.
+    # 
+    # This call will fail if:
+    #     - The Item conflicts with an existing Item at the same path and the
+    #       must_not_exist option is set, or the item's ID will be chosen with
+    #       an `initialValue` and one of its other key paths conflicts with an
+    #       existing item.
     # 
-    # _@param_ `item` — a StatelyDB Item
+    # _@param_ `item` — An Item from your generated schema.
     # 
     # _@param_ `must_not_exist` — A condition that indicates this item must not already exist at any of its key paths. If there is already an item at one of those paths, the Put operation will fail with a "ConditionalCheckFailed" error. Note that if the item has an `initialValue` field in its key, that initial value will automatically be chosen not to conflict with existing items, so this condition only applies to key paths that do not contain the `initialValue` field.
     # 
     # _@param_ `overwrite_metadata_timestamps` — If set to true, the server will set the `createdAtTime` and/or `lastModifiedAtTime` fields based on the current values in this item (assuming you've mapped them to a field using `fromMetadata`). Without this, those fields are always ignored and the server sets them to the appropriate times. This option can be useful when migrating data from another system.
     # 
-    # _@return_ — the item that was stored
+    # _@return_ — The item that was put, with any server-generated fields filled in.
     # 
     # client.data.put(my_item)
     # ```ruby
@@ -377,13 +440,21 @@ module StatelyDB
     sig { params(item: StatelyDB::Item, must_not_exist: T::Boolean, overwrite_metadata_timestamps: T::Boolean).returns(StatelyDB::Item) }
     def put(item, must_not_exist: false, overwrite_metadata_timestamps: false); end
 
-    # Put a batch of up to 50 Items into a StatelyDB Store.
+    # put_batch adds multiple Items to the Store, or replaces Items if they
+    # already exist at that path. You can put items of different types in a
+    # single put_batch. All puts in the request are applied atomically - there
+    # are no partial successes.
     # 
-    # Max 50 items.
+    # This will fail if:
+    #   - Any Item conflicts with an existing Item at the same path and its
+    #     must_not_exist option is set, or the item's ID will be chosen with an
+    #     `initialValue` and one of its other key paths conflicts with an existing
+    #     item.
     # 
-    # _@param_ `items` — the items to store.
+    # _@param_ `items` — Items from your generated schema.
     # 
-    # _@return_ — the items that were stored
+    # _@return_ — The items that were put, with any server-generated fields filled in.
+    # They are returned in the same order they were provided.
     # 
     # ```ruby
     # client.data.put_batch(item1, item2)
@@ -395,21 +466,47 @@ module StatelyDB
     sig { params(items: T.any(StatelyDB::Item, T::Array[StatelyDB::Item])).returns(T::Array[StatelyDB::Item]) }
     def put_batch(*items); end
 
-    # Delete up to 50 Items from a StatelyDB Store at the given key_paths.
+    # delete removes one or more items from the Store by their full key paths.
+    # delete succeeds even if there isn't an item at that key path. Tombstones
+    # will be saved for deleted items for some time, so that sync_list can
+    # return information about deleted items. Deletes are always applied
+    # atomically; all will fail or all will succeed.
+    # 
+    # The full key paths of the items. @raise [StatelyDB::Error] if the
+    # parameters are invalid @raise [StatelyDB::Error] if the item is not found
     # 
-    # _@param_ `key_paths` — the paths to the items. Max 50 key paths.
+    # _@param_ `key_paths`
     # 
     # _@return_ — nil
     # 
+    # client.data.delete("/ItemType-identifier",
     # ```ruby
-    # client.data.delete("/ItemType-identifier", "/ItemType-identifier2")
+    # "/ItemType-identifier2")
     # ```
     sig { params(key_paths: T.any(StatelyDB::KeyPath, String, T::Array[T.any(StatelyDB::KeyPath, String)])).void }
     def delete(*key_paths); end
 
-    # Transaction takes a block and executes the block within a transaction.
-    # If the block raises an exception, the transaction is rolled back.
-    # If the block completes successfully, the transaction is committed.
+    # transaction allows you to issue reads and writes in any order, and all
+    # writes will either succeed or all will fail when the transaction finishes.
+    # It takes a block with a single argument that can be used to run commands
+    # within the transaction.
+    # 
+    # Reads are guaranteed to reflect the state as of when the transaction
+    # started. A transaction may fail if another transaction commits before this
+    # one finishes - in that case, you should retry your transaction.
+    # 
+    # If any error is thrown from the block, the transaction is aborted and none
+    # of the changes made in it will be applied. If the handler returns without
+    # error, the transaction is automatically committed.
+    # 
+    # If any of the operations in the block fails (e.g. a request is invalid)
+    # you may not find out until the *next* operation, or once the block
+    # finishes, due to some technicalities about how requests are handled.
+    # 
+    # When the transaction is committed, the result property will contain the
+    # full version of any items that were put in the transaction, and the
+    # committed property will be True. If the transaction was aborted, the
+    # committed property will be False.
     # 
     # _@return_ — the result of the transaction
     # 
@@ -919,10 +1016,9 @@ module StatelyDB
       sig { returns(T::Boolean) }
       def open?; end
 
-      # Fetch Items from a StatelyDB Store at the given key_path. Note that Items need to exist before being retrieved inside a
-      # transaction.
+      # get retrieves an item by its full key path.
       # 
-      # _@param_ `key_path` — the path to the item
+      # _@param_ `key_path` — The full key path of the item.
       # 
       # _@return_ — the item or nil if not found
       # 
@@ -934,9 +1030,12 @@ module StatelyDB
       sig { params(key_path: T.any(StatelyDB::KeyPath, String)).returns(T.any(StatelyDB::Item, NilClass)) }
       def get(key_path); end
 
-      # Fetch a batch of up to 100 Items from a StatelyDB Store at the given
-      # key_paths. Note that Items need to exist before being retrieved inside a
-      # transaction.
+      # get_batch retrieves multiple items by their full key paths. This will
+      # return the corresponding items that exist. Use begin_list instead if you
+      # want to retrieve multiple items but don't already know the full key
+      # paths of the items you want to get. You can get items of different types
+      # in a single get_batch - you will need to check the class of each result
+      # to determine what item type each item is.
       # 
       # key paths.
       # Example:
@@ -944,27 +1043,35 @@ module StatelyDB
       #     items = txn.get_batch("/foo", "/bar")
       #   end
       # 
-      # _@param_ `key_paths` — the paths to the items. Max 100
+      # _@param_ `key_paths` — the paths to the items.
       # 
       # _@return_ — the items
       sig { params(key_paths: T.any(StatelyDB::KeyPath, String, T::Array[T.any(StatelyDB::KeyPath, String)])).returns(T::Array[StatelyDB::Item]) }
       def get_batch(*key_paths); end
 
-      # Put a single Item into a StatelyDB store. Results are not returned until the transaction is
-      # committed and will be available in the Result object returned by commit. An identifier for
-      # the item will be returned while inside the transaction block.
+      # put adds an Item to the Store, or replaces the Item if it already exists
+      # at that path. Unlike the put method outside of a transaction, this only
+      # returns the generated ID of the item, and then only if the item was
+      # newly created and has an `initialValue` field in its key. This is so you
+      # can use that ID in subsequent puts to reference newly created items. The
+      # final put items will not be returned until the transaction is committed,
+      # in which case they will be included in the `StatelyDB::Transaction::Transaction::Result.puts`
+      # list.
       # 
       #  results.puts.each do |result|
       #    puts result.key_path
       #  end
       # 
-      # _@param_ `item` — the item to store
+      # _@param_ `item` — the item to put
       # 
       # _@param_ `must_not_exist` — A condition that indicates this item must not already exist at any of its key paths. If there is already an item at one of those paths, the Put operation will fail with a "ConditionalCheckFailed" error. Note that if the item has an `initialValue` field in its key, that initial value will automatically be chosen not to conflict with existing items, so this condition only applies to key paths that do not contain the `initialValue` field.
       # 
       # _@param_ `overwrite_metadata_timestamps` — If set to true, the server will set the `createdAtTime` and/or `lastModifiedAtTime` fields based on the current values in this item (assuming you've mapped them to a field using `fromMetadata`). Without this, those fields are always ignored and the server sets them to the appropriate times. This option can be useful when migrating data from another system.
       # 
-      # _@return_ — the id of the item
+      # _@return_ — a generated IDs for the item, if that item had an ID generated
+      # for its "initialValue" field. Otherwise the value is None. This
+      # value can be used in subsequent puts to reference newly created
+      # items.
       # 
       # ```ruby
       # results = client.data.transaction do |txn|
@@ -974,19 +1081,27 @@ module StatelyDB
       sig { params(item: StatelyDB::Item, must_not_exist: T::Boolean, overwrite_metadata_timestamps: T::Boolean).returns(T.any(String, Integer)) }
       def put(item, must_not_exist: false, overwrite_metadata_timestamps: false); end
 
-      # Put a batch of up to 50 Items into a StatelyDB Store. Results are not
-      # returned until the transaction is committed and will be available in the
-      # Result object returned by commit. A list of identifiers for the items
-      # will be returned while inside the transaction block.
+      # put_batch adds multiple Items to the Store, or replaces Items if they
+      # already exist at that path. You can put items of different types in a
+      # single put_batch. Unlike the put_batch method outside of a transaction,
+      # this only returns the generated IDs of the items, and then only if the
+      # item was newly created and has an `initialValue` field in its key. The
+      # IDs are returned in the same order as the inputs. This is so you can use
+      # that ID in subsequent puts to reference newly created items. The final
+      # put items will not be returned until the transaction is committed, in
+      # which case they will be included in the `StatelyDB::Transaction::Transaction::Result.puts` list.
       # 
-      # 50 items.
       #  results.puts.each do |result|
       #    puts result.key_path
       #  end
       # 
-      # _@param_ `items` — the items to store. Max
+      # _@param_ `items` — the items to put
       # 
-      # _@return_ — the ids of the items
+      # _@return_ — an array of
+      # generated IDs for each item, if that item had an ID generated for its
+      # "initialValue" field. Otherwise the value is None.
+      # These are returned in the same order as the input items. This value
+      # can be used in subsequent puts to reference newly created items.
       # 
       # ```ruby
       # results = client.data.transaction do |txn|
@@ -996,44 +1111,88 @@ module StatelyDB
       sig { params(items: T.any(StatelyDB::Item, T::Array[StatelyDB::Item])).returns(T::Array[T.any(StatelyDB::UUID, String, Integer, NilClass)]) }
       def put_batch(*items); end
 
-      # Delete up to 50 Items from a StatelyDB Store at the given key_paths. Results are not returned until the transaction is
-      # committed and will be available in the Result object returned by commit.
+      # delete removes one or more items from the Store by their full key paths.
+      # delete succeeds even if there isn't an item at that key path.
       # 
       # Example:
       #   client.data.transaction do |txn|
       #     txn.delete("/ItemType-identifier", "/ItemType-identifier2")
       #   end
       # 
-      # _@param_ `key_paths` — the paths to the items. Max 50 key paths.
+      # _@param_ `key_paths` — The full key paths of the items
       # 
       # _@return_ — nil
       sig { params(key_paths: T.any(StatelyDB::KeyPath, String, T::Array[T.any(StatelyDB::KeyPath, String)])).void }
       def delete(*key_paths); end
 
+      # begin_list retrieves Items that start with a specified key_path_prefix
+      # from a single Group. Because it can only list items from a single Group,
+      # the key path prefix must at least start with a full Group Key (a single
+      # key segment with a namespace and an ID, e.g. `/user-1234`).
+      # 
+      # begin_list will return an empty result set if there are no items
+      # matching that key prefix. This API returns a token that you can pass to
+      # continue_list to expand the result set.
+      # 
+      # You can list items of different types in a single begin_list, and you
+      # can check the class of each result to handle different item types.
+      # 
       # Example:
       #   client.data.transaction do |txn|
       #     (items, token) = txn.begin_list("/ItemType-identifier")
       #     (items, token) = txn.continue_list(token)
       #   end
       # 
+      # _@param_ `prefix` — the key path prefix to query for. It must be at least a full Group Key (e.g. `/user-1234`).
+      # 
+      # _@param_ `limit` — the max number of Items to retrieve. Defaults to 0 which fetches all Items.
+      # 
+      # _@param_ `sort_direction` — the direction to sort by (:ascending or :descending)
+      # 
+      # _@param_ `item_types` — the item types to filter by. The returned items will be instances of one of these types.
+      # 
+      # _@param_ `cel_filters` — ] An optional list of item_type, cel_expression tuples that represent CEL expressions to filter the results set by. Use the cel_filter helper function to build these expressions. CEL expressions are only evaluated for the item type they are defined for, and do not affect other item types in the result set. This means if an item type has no CEL filter and there are no item_type filters constraints, it will be included in the result set. In the context of a CEL expression, the key-word `this` refers to the item being evaluated, and property properties should be accessed by the names as they appear in schema -- not necessarily as they appear in the generated code for a particular language. For example, if you have a `Movie` item type with the property `rating`, you could write a CEL expression like `this.rating == 'R'` to return only movies that are rated `R`. Find the full CEL language definition here: https://github.com/google/cel-spec/blob/master/doc/langdef.md
+      # 
+      # _@param_ `gt` — filters results to only include items with a key greater than the specified value based on lexicographic ordering.
+      # 
+      # _@param_ `gte` — filters results to only include items with a key greater than or equal to the specified value based on lexicographic ordering.
+      # 
+      # _@param_ `lt` — filters results to only include items with a key less than the specified value based on lexicographic ordering.
+      # 
+      # _@param_ `lte` — filters results to only include items with a key less than or equal to the specified value based on lexicographic ordering.
+      # 
       # _@return_ — the list of Items and the token
       sig do
         params(
-          prefix: T.untyped,
-          limit: T.untyped,
-          sort_property: T.untyped,
-          sort_direction: T.untyped,
-          item_types: T.untyped,
-          cel_filters: T.untyped,
-          gt: T.untyped,
-          gte: T.untyped,
-          lt: T.untyped,
-          lte: T.untyped
+          prefix: T.any(StatelyDB::KeyPath, String),
+          limit: Integer,
+          sort_direction: Symbol,
+          item_types: T::Array[T.any(StatelyDB::Item, String)],
+          cel_filters: T::Array[T.any(T::Array[T.any(T::Class[T.anything], String)], String)],
+          gt: T.nilable(T.any(StatelyDB::KeyPath, String)),
+          gte: T.nilable(T.any(StatelyDB::KeyPath, String)),
+          lt: T.nilable(T.any(StatelyDB::KeyPath, String)),
+          lte: T.nilable(T.any(StatelyDB::KeyPath, String))
         ).returns([T::Array[StatelyDB::Item], ::Stately::Db::ListToken])
       end
-      def begin_list(prefix, limit: 100, sort_property: nil, sort_direction: :ascending, item_types: [], cel_filters: [], gt: nil, gte: nil, lt: nil, lte: nil); end
-
-      # Continue listing Items from a StatelyDB Store using a token.
+      def begin_list(prefix, limit: 100, sort_direction: :ascending, item_types: [], cel_filters: [], gt: nil, gte: nil, lt: nil, lte: nil); end
+
+      # continue_list takes the token from a begin_list call and returns the
+      # next "page" of results based on the original query parameters and
+      # pagination options. It doesn't have options because it is a continuation
+      # of a previous list operation. It will return a new token which can be
+      # used for another continue_list call, and so on. The token is the same
+      # one used by sync_list - each time you call either continue_list or
+      # sync_list, you should pass the latest version of the token, and the
+      # result will include a new version of the token to use in subsequent
+      # calls. You may interleave continue_list and sync_list calls however you
+      # like, but it does not make sense to make both calls in parallel. Calls
+      # to continue_list are tied to the authorization of the original
+      # begin_list call, so if the original begin_list call was allowed,
+      # continue_list with its token should also be allowed.
+      # 
+      # You can list items of different types in a single continueList, and you can
+      # check the class of each result to handle different item types.
       # 
       # Example:
       #   client.data.transaction do |txn|
@@ -1041,7 +1200,7 @@ module StatelyDB
       #     (items, token) = txn.continue_list(token)
       #   end
       # 
-      # _@param_ `token` — the token to continue from
+      # _@param_ `token` — the token from the previous list operation
       # 
       # _@param_ `continue_direction` — the direction to continue by (:forward or :backward)
       #