statelydb 0.21.0 → 0.23.0

data/rbi/db/scan_root_paths_pb.rbi

@@ -0,0 +1,301 @@
+# Code generated by protoc-gen-rbi. DO NOT EDIT.
+# source: db/scan_root_paths.proto
+# typed: strict
+
+class Stately::Db::ScanRootPathsRequest
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      store_id: T.nilable(Integer),
+      limit: T.nilable(Integer),
+      pagination_token: T.nilable(String),
+      schema_version_id: T.nilable(Integer),
+      schema_id: T.nilable(Integer)
+    ).void
+  end
+  def initialize(
+    store_id: 0,
+    limit: 0,
+    pagination_token: "",
+    schema_version_id: 0,
+    schema_id: 0
+  )
+  end
+
+  # store_id is a globally unique Store ID, which can be looked up from the
+# console or CLI.
+  sig { returns(Integer) }
+  def store_id
+  end
+
+  # store_id is a globally unique Store ID, which can be looked up from the
+# console or CLI.
+  sig { params(value: Integer).void }
+  def store_id=(value)
+  end
+
+  # store_id is a globally unique Store ID, which can be looked up from the
+# console or CLI.
+  sig { void }
+  def clear_store_id
+  end
+
+  # Limit sets an upper bound on how many root paths to return.
+  sig { returns(Integer) }
+  def limit
+  end
+
+  # Limit sets an upper bound on how many root paths to return.
+  sig { params(value: Integer).void }
+  def limit=(value)
+  end
+
+  # Limit sets an upper bound on how many root paths to return.
+  sig { void }
+  def clear_limit
+  end
+
+  # pagination_token is an optional token to continue retrieving the next page of results.
+# This value must be read from a ScanRootPathsResponse and passed with a clone of the
+# previous request to fetch the next page of data
+  sig { returns(String) }
+  def pagination_token
+  end
+
+  # pagination_token is an optional token to continue retrieving the next page of results.
+# This value must be read from a ScanRootPathsResponse and passed with a clone of the
+# previous request to fetch the next page of data
+  sig { params(value: String).void }
+  def pagination_token=(value)
+  end
+
+  # pagination_token is an optional token to continue retrieving the next page of results.
+# This value must be read from a ScanRootPathsResponse and passed with a clone of the
+# previous request to fetch the next page of data
+  sig { void }
+  def clear_pagination_token
+  end
+
+  # schema_version_id is the version of the schema to base all queries on.
+  sig { returns(Integer) }
+  def schema_version_id
+  end
+
+  # schema_version_id is the version of the schema to base all queries on.
+  sig { params(value: Integer).void }
+  def schema_version_id=(value)
+  end
+
+  # schema_version_id is the version of the schema to base all queries on.
+  sig { void }
+  def clear_schema_version_id
+  end
+
+  # schema_id refers to the schema to use for this operation.
+# If the store_id does not have a schema with this ID, the operation will
+# error with SchemaNotFound error. You should not have to set this manually
+# as your generated SDK should know its schema and wire this in for you.
+  sig { returns(Integer) }
+  def schema_id
+  end
+
+  # schema_id refers to the schema to use for this operation.
+# If the store_id does not have a schema with this ID, the operation will
+# error with SchemaNotFound error. You should not have to set this manually
+# as your generated SDK should know its schema and wire this in for you.
+  sig { params(value: Integer).void }
+  def schema_id=(value)
+  end
+
+  # schema_id refers to the schema to use for this operation.
+# If the store_id does not have a schema with this ID, the operation will
+# error with SchemaNotFound error. You should not have to set this manually
+# as your generated SDK should know its schema and wire this in for you.
+  sig { void }
+  def clear_schema_id
+  end
+
+  sig { params(field: String).returns(T.untyped) }
+  def [](field)
+  end
+
+  sig { params(field: String, value: T.untyped).void }
+  def []=(field, value)
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def to_h
+  end
+
+  sig { params(str: String).returns(Stately::Db::ScanRootPathsRequest) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Stately::Db::ScanRootPathsRequest).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Stately::Db::ScanRootPathsRequest) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Stately::Db::ScanRootPathsRequest, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Stately::Db::ScanRootPathsResponse
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      results: T.nilable(T::Array[T.nilable(Stately::Db::ScanRootPathResult)]),
+      pagination_token: T.nilable(String)
+    ).void
+  end
+  def initialize(
+    results: [],
+    pagination_token: ""
+  )
+  end
+
+  # results is a list that contains one entry for each root path that was found.
+  sig { returns(T::Array[T.nilable(Stately::Db::ScanRootPathResult)]) }
+  def results
+  end
+
+  # results is a list that contains one entry for each root path that was found.
+  sig { params(value: ::Google::Protobuf::RepeatedField).void }
+  def results=(value)
+  end
+
+  # results is a list that contains one entry for each root path that was found.
+  sig { void }
+  def clear_results
+  end
+
+  # This field is optional and will be set if there are more query results to fetch.
+# To fetch the next page of results you must make the exact same ScanRootPathsRequest as before
+# but set ScanRootPathsRequest.pagination_token to the value returned here.
+  sig { returns(String) }
+  def pagination_token
+  end
+
+  # This field is optional and will be set if there are more query results to fetch.
+# To fetch the next page of results you must make the exact same ScanRootPathsRequest as before
+# but set ScanRootPathsRequest.pagination_token to the value returned here.
+  sig { params(value: String).void }
+  def pagination_token=(value)
+  end
+
+  # This field is optional and will be set if there are more query results to fetch.
+# To fetch the next page of results you must make the exact same ScanRootPathsRequest as before
+# but set ScanRootPathsRequest.pagination_token to the value returned here.
+  sig { void }
+  def clear_pagination_token
+  end
+
+  sig { params(field: String).returns(T.untyped) }
+  def [](field)
+  end
+
+  sig { params(field: String, value: T.untyped).void }
+  def []=(field, value)
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def to_h
+  end
+
+  sig { params(str: String).returns(Stately::Db::ScanRootPathsResponse) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Stately::Db::ScanRootPathsResponse).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Stately::Db::ScanRootPathsResponse) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Stately::Db::ScanRootPathsResponse, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Stately::Db::ScanRootPathResult
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      key_path: T.nilable(String)
+    ).void
+  end
+  def initialize(
+    key_path: ""
+  )
+  end
+
+  # key_path is a single root key path. Users can Query by this root path to
+# get all of the items under it.
+  sig { returns(String) }
+  def key_path
+  end
+
+  # key_path is a single root key path. Users can Query by this root path to
+# get all of the items under it.
+  sig { params(value: String).void }
+  def key_path=(value)
+  end
+
+  # key_path is a single root key path. Users can Query by this root path to
+# get all of the items under it.
+  sig { void }
+  def clear_key_path
+  end
+
+  sig { params(field: String).returns(T.untyped) }
+  def [](field)
+  end
+
+  sig { params(field: String, value: T.untyped).void }
+  def []=(field, value)
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def to_h
+  end
+
+  sig { params(str: String).returns(Stately::Db::ScanRootPathResult) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Stately::Db::ScanRootPathResult).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Stately::Db::ScanRootPathResult) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Stately::Db::ScanRootPathResult, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end

data/rbi/db/service_pb.rbi

@@ -0,0 +1,3 @@
+# Code generated by protoc-gen-rbi. DO NOT EDIT.
+# source: db/service.proto
+# typed: strict

data/rbi/db/service_services_pb.rbi

@@ -0,0 +1,184 @@
+# Code generated by protoc-gen-rbi. DO NOT EDIT.
+# source: db/service.proto
+# typed: strict
+
+module Stately::Db::DatabaseService
+  class Service
+    include ::GRPC::GenericService
+  end
+
+  class Stub < ::GRPC::ClientStub
+    sig do
+      params(
+        host: String,
+        creds: T.any(::GRPC::Core::ChannelCredentials, Symbol),
+        kw: T.untyped,
+      ).void
+    end
+    def initialize(host, creds, **kw)
+    end
+
+    # Put adds one or more Items to the Store, or replaces the Items if they
+# already exist. This will fail if the caller does not have permission to
+# create or update Items, if there is no schema registered for the provided
+# item type, or if an item is invalid. All puts are applied atomically;
+# either all will fail or all will succeed. If an item's schema specifies an
+# `initialValue` for one or more properties used in its key paths, and the
+# item is new, you should not provide those values - the database will choose
+# them for you, and Data must be provided as either serialized binary
+# protobuf or JSON.
+    sig do
+      params(
+        request: Stately::Db::PutRequest
+      ).returns(Stately::Db::PutResponse)
+    end
+    def put(request)
+    end
+
+    # Get retrieves one or more Items by their key paths. This will return any of
+# the Items that exist. It will fail if the caller does not have permission
+# to read Items. Use the List APIs if you want to retrieve multiple items but
+# don't already know the full key paths of the items you want to get.
+    sig do
+      params(
+        request: Stately::Db::GetRequest
+      ).returns(Stately::Db::GetResponse)
+    end
+    def get(request)
+    end
+
+    # Delete removes one or more Items from the Store by their key paths. This
+# will fail if the caller does not have permission to delete Items.
+# Tombstones will be saved for deleted items for some time, so
+# that SyncList can return information about deleted items. Deletes are
+# always applied atomically; all will fail or all will succeed.
+    sig do
+      params(
+        request: Stately::Db::DeleteRequest
+      ).returns(Stately::Db::DeleteResponse)
+    end
+    def delete(request)
+    end
+
+    # BeginList retrieves Items that start with a specified key path prefix. The
+# key path prefix must minimally contain a Group Key (a single key segment
+# with a namespace and an ID). BeginList 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 ContinueList to expand the result set, or to SyncList to
+# get updates within the result set. This can fail if the caller does not
+# have permission to read Items.
+# buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
+    sig do
+      params(
+        request: Stately::Db::BeginListRequest
+      ).returns(T::Enumerable[Stately::Db::ListResponse])
+    end
+    def begin_list(request)
+    end
+
+    # ContinueList takes the token from a BeginList call and returns more results
+# based on the original query parameters and pagination options. It has very
+# few options of its own because it is a continuation of a previous list
+# operation. It will return a new token which can be used for another
+# ContinueList call, and so on. The token is the same one used by SyncList -
+# each time you call either ContinueList or SyncList, you should pass the
+# latest version of the token, and then use the new token from the result in
+# subsequent calls. You may interleave ContinueList and SyncList calls
+# however you like, but it does not make sense to make both calls in
+# parallel. Calls to ContinueList are tied to the authorization of the
+# original BeginList call, so if the original BeginList call was allowed,
+# ContinueList with its token should also be allowed.
+# buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
+    sig do
+      params(
+        request: Stately::Db::ContinueListRequest
+      ).returns(T::Enumerable[Stately::Db::ListResponse])
+    end
+    def continue_list(request)
+    end
+
+    # BeginScan 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 ContinueScan 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.
+# buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
+    sig do
+      params(
+        request: Stately::Db::BeginScanRequest
+      ).returns(T::Enumerable[Stately::Db::ListResponse])
+    end
+    def begin_scan(request)
+    end
+
+    # ContinueScan takes the token from a BeginScan call and returns more results
+# based on the original request parameters and pagination options. It has
+# very few options of its own because it is a continuation of a previous list
+# operation. It will return a new token which can be used for another
+# ContinueScan call, and so on. Calls to ContinueScan are tied to the
+# authorization of the original BeginScan call, so if the original BeginScan
+# call was allowed, ContinueScan with its token should also be allowed.
+# WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER OF ITEMS.
+# buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
+    sig do
+      params(
+        request: Stately::Db::ContinueScanRequest
+      ).returns(T::Enumerable[Stately::Db::ListResponse])
+    end
+    def continue_scan(request)
+    end
+
+    # SyncList 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. It also returns a list of
+# Item key paths that were deleted since the last SyncList, which you should
+# reconcile with your view of items returned from previous
+# BeginList/ContinueList calls. Using this API, you can start with an initial
+# set of items from BeginList, and then stay up to date on any changes via
+# repeated SyncList requests over time. The token is the same one used by
+# ContinueList - each time you call either ContinueList or SyncList, you
+# should pass the latest version of the token, and then use the new token
+# from the result in subsequent calls. Note that if the result set has
+# already been expanded to the end (in the direction of the original
+# BeginList request), SyncList will return newly created Items. You may
+# interleave ContinueList and SyncList calls however you like, but it does
+# not make sense to make both calls in parallel. Calls to SyncList are tied
+# to the authorization of the original BeginList call, so if the original
+# BeginList call was allowed, SyncList with its token should also be allowed.
+    sig do
+      params(
+        request: Stately::Db::SyncListRequest
+      ).returns(T::Enumerable[Stately::Db::SyncListResponse])
+    end
+    def sync_list(request)
+    end
+
+    # Transaction performs a transaction, within which you can issue writes
+# (Put/Delete) and reads (Get/List) in any order, followed by a commit
+# message. Reads are guaranteed to reflect the state as of when the
+# transaction started, and writes are committed atomically. This method may
+# fail if another transaction commits before this one finishes - in that
+# case, you should retry your transaction.
+    sig do
+      params(
+        request: T::Enumerable[Stately::Db::TransactionRequest]
+      ).returns(T::Enumerable[Stately::Db::TransactionResponse])
+    end
+    def transaction(request)
+    end
+
+    # ScanRootPaths lists root paths (Groups) in the Store. This is a very
+# expensive operation, as it must consult multiple partitions and it reads
+# and ignores a lot of data. It is provided for use in the web console's data
+# browser and is not exposed to customers. This operation will fail if the
+# caller does not have permission to read Items.
+    sig do
+      params(
+        request: Stately::Db::ScanRootPathsRequest
+      ).returns(Stately::Db::ScanRootPathsResponse)
+    end
+    def scan_root_paths(request)
+    end
+  end
+end