typed_cache 0.3.2 → 0.4.0.pre.1

data/rbi/typed_cache/maybe.rbi

@@ -77,6 +77,18 @@ module TypedCache
 
     sig { override.returns(V) }
     def value_or_raise!; end
+
+    sig { returns(String) }
+    def to_s; end
+
+    sig { returns(String) }
+    def inspect; end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other); end
+
+    sig { returns(Integer) }
+    def hash; end
   end
 
   class Nothing
@@ -104,5 +116,17 @@ module TypedCache
 
     sig { override.returns(T.noreturn) }
     def value_or_raise!; end
+
+    sig { returns(String) }
+    def to_s; end
+
+    sig { returns(String) }
+    def inspect; end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other); end
+
+    sig { returns(Integer) }
+    def hash; end
   end
 end

data/rbi/typed_cache/namespace.rbi

@@ -26,5 +26,19 @@ module TypedCache
 
     sig { returns(String) }
     def to_s; end
+
+    sig { returns(String) }
+    def inspect; end
+
+    sig { returns(Integer) }
+    def hash; end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other); end
+
+    private
+
+    sig { returns(String) }
+    def delimiter; end
   end
 end

data/rbi/typed_cache/snapshot.rbi

@@ -40,6 +40,12 @@ module TypedCache
 
     alias flat_map bind
 
+    sig { returns(String) }
+    def to_s; end
+
+    sig { returns(String) }
+    def inspect; end
+
     class << self
       sig { type_parameters(:T).params(key: ::TypedCache::CacheKey, value: T.type_parameter(:T)).returns(::TypedCache::Snapshot[T.type_parameter(:T)]) }
       def cached(key, value); end

data/rbi/typed_cache/store.rbi

@@ -12,10 +12,16 @@ module TypedCache
     Key = T.type_alias { T.any(String, ::TypedCache::CacheKey) }
     private_constant :Error, :Key
 
-    sig { params(key: Key, kwargs: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, CachedType]) }
+    sig { returns(::TypedCache::Backend[CachedType]) }
+    def backend; end
+
+    sig { params(key: Key, kwargs: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[::TypedCache::Maybe[CachedType]]]) }
     def read(key, **kwargs); end
 
-    sig { params(keys: T::Array[Key], kwargs: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
+    sig do
+      type_parameters(:K)
+        .params(keys: T::Array[T.all(Key, T.type_parameter(:K))], kwargs: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, T::Hash[T.all(Key, T.type_parameter(:K)), ::TypedCache::Snapshot[CachedType]]])
+    end
     def read_all(keys, **kwargs); end
 
     sig { params(key: Key, value: CachedType, kwargs: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
@@ -24,7 +30,7 @@ module TypedCache
     sig { params(values: T::Hash[Key, CachedType], kwargs: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
     def write_all(values, **kwargs); end
 
-    sig { params(key: Key).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
+    sig { params(key: Key).returns(::TypedCache::Either[Error, ::TypedCache::Maybe[CachedType]]) }
     def delete(key); end
 
     sig { params(key: Key).returns(::TypedCache::CacheRef[CachedType]) }
@@ -36,10 +42,16 @@ module TypedCache
     sig { params(key: Key).returns(T::Boolean) }
     def key?(key); end
 
-    sig { params(key: Key, kwargs: T::Hash[Symbol, T.untyped], block: T.proc.returns(T.nilable(CachedType))).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[::TypedCache::Maybe[CachedType]]]) }
+    sig do
+      type_parameters(:K)
+        .params(key: T.all(Key, T.type_parameter(:K)), kwargs: T::Hash[Symbol, T.untyped], block: T.proc.params(key: T.all(Key, T.type_parameter(:K))).returns(T.nilable(CachedType))).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[::TypedCache::Maybe[CachedType]]])
+    end
     def fetch(key, **kwargs, &block); end
 
-    sig { params(keys: T::Array[Key], kwargs: T::Hash[Symbol, T.untyped], block: T.proc.params(key: ::TypedCache::CacheKey).returns(T.nilable(CachedType))).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
+    sig do
+      type_parameters(:K)
+        .params(keys: T::Array[T.all(Key, T.type_parameter(:K))], kwargs: T::Hash[Symbol, T.untyped], block: T.proc.params(key: T.all(Key, T.type_parameter(:K))).returns(T.nilable(CachedType))).returns(::TypedCache::Either[Error, T::Hash[T.all(Key, T.type_parameter(:K)), ::TypedCache::Snapshot[CachedType]]])
+    end
     def fetch_all(keys, **kwargs, &block); end
 
     sig { returns(::TypedCache::Namespace) }
@@ -48,24 +60,14 @@ module TypedCache
     sig { params(ns: T.any(::TypedCache::Namespace, String, T::Array[String])).returns(::TypedCache::Store[CachedType]) }
     def with_namespace(ns); end
 
-    sig { returns(String) }
-    def store_type; end
-
-    sig { returns(T.self_type) }
-    def clone; end
-
-    sig { params(key: Key).returns(::TypedCache::CacheKey) }
-    def namespaced_key(key); end
-
-    sig { returns(::TypedCache::Instrumenter) }
-    def instrumenter; end
-
-    protected
-
-    sig { params(string: String).returns(String) }
-    def snake_case(string); end
-
-    sig { params(namespace: ::TypedCache::Namespace).returns(::TypedCache::Namespace) }
-    def nested_namespace(namespace); end
+    sig { params(ns: T.any(::TypedCache::Namespace, String, T::Array[String])).returns(::TypedCache::Store[CachedType]) }
+    def at_namespace(ns); end
+
+    sig do
+      type_parameters(:T)
+        .params(klass: T::Class[T.type_parameter(:T)], at: T.nilable(T.any(::TypedCache::Namespace, String)))
+        .returns(::TypedCache::Store[T.type_parameter(:T)])
+    end
+    def cache_for(klass, at: T.unsafe(nil)); end
   end
 end

data/rbi/typed_cache.rbi

@@ -32,7 +32,7 @@ module TypedCache
     sig { returns(::TypedCache::Private::Configuration) }
     def config; end
 
-    sig { returns(::TypedCache::CacheBuilder) }
+    sig { returns(::TypedCache::CacheDefinition) }
     def builder; end
 
     sig { returns(T.class_of(::TypedCache::Backends)) }

data/sig/generated/typed_cache/backend.rbs

@@ -10,8 +10,74 @@ module TypedCache
   # that actually persist data.
   # @rbs generic V
   module Backend[V]
-    include Store[V]
+    type cache_key = String | CacheKey
 
-    include Store::_Store[V]
+    interface _Backend[V]
+      def read: (cache_key, **top) -> V?
+
+      def read_multi: (Array[cache_key], **top) -> Hash[cache_key, V]
+
+      def write: (cache_key, V, **top) -> V
+
+      def write_multi: (Hash[cache_key, V], **top) -> Hash[cache_key, V]
+
+      def delete: (cache_key) -> V?
+
+      def key?: (cache_key) -> bool
+
+      def clear: () -> void
+
+      def fetch: (cache_key, **top) { () -> V? } -> V?
+
+      def fetch_multi: (Array[cache_key], **top) { (cache_key) -> V? } -> Hash[cache_key, V]
+    end
+
+    include _Backend[V]
+
+    # @rbs override
+    # @rbs (cache_key, **top) -> V?
+    def read: ...
+
+    # @rbs override
+    # @rbs (Array[cache_key], **top) -> Hash[cache_key, V]
+    def read_multi: ...
+
+    # @rbs override
+    # @rbs (cache_key, V, **top) -> V
+    def write: ...
+
+    # @rbs override
+    # @rbs (Hash[cache_key, V], **top) -> Hash[cache_key, V]
+    def write_multi: ...
+
+    # @rbs override
+    # @rbs (cache_key) -> V?
+    def delete: ...
+
+    # @rbs override
+    # @rbs (cache_key) -> bool
+    def key?: ...
+
+    # @rbs override
+    # @rbs () -> void
+    def clear: ...
+
+    # @rbs override
+    # @rbs (cache_key, **top) { () -> V? } -> V?
+    def fetch: ...
+
+    # @rbs override
+    # @rbs (Array[cache_key], **top) { (cache_key) -> V? } -> Hash[cache_key, V]
+    def fetch_multi: ...
+
+    # @rbs override
+    # @rbs () -> String
+    def to_s: ...
+
+    # @rbs override
+    # @rbs () -> String
+    def inspect: ...
   end
+
+  type backend[V] = Backend::_Backend[V]
 end

data/sig/generated/typed_cache/backends/active_support.rbs

@@ -7,37 +7,39 @@ module TypedCache
     class ActiveSupport[V]
       include Backend[V]
 
-      attr_reader namespace: Namespace
-
       attr_reader cache_store: ::ActiveSupport::Cache::Store
 
       attr_reader default_options: Hash[Symbol, top]
 
-      # : (Namespace, ::ActiveSupport::Cache::Store, ?Hash[Symbol, top]) -> void
-      def initialize: (Namespace, ::ActiveSupport::Cache::Store, ?Hash[Symbol, top]) -> void
+      # : (::ActiveSupport::Cache::Store, ?Hash[Symbol, top]) -> void
+      def initialize: (::ActiveSupport::Cache::Store, ?Hash[Symbol, top]) -> void
 
       # @rbs override
-      # : (cache_key, **top) -> either[Error, Snapshot[V]]
+      # : (cache_key, **top) -> V?
       def read: ...
 
       # @rbs override
-      # : (cache_key, V, **top) -> either[Error, Snapshot[V]]
+      # : (cache_key, V, **top) -> V
       def write: ...
 
       # @rbs override
-      # : (Hash[cache_key, V], **top) -> either[Error, Array[Snapshot[V]]]
+      # : (Hash[cache_key, V], **top) -> Array[V]
       def write_all: ...
 
       # @rbs override
-      # : (cache_key) -> either[Error, Snapshot[V]]
+      # : (cache_key) -> V?
       def delete: ...
 
       # @rbs override
-      # : (Array[cache_key], **top) -> either[Error, Array[Snapshot[V]]]
+      # : (Array[cache_key], **top) -> Hash[cache_key, V]
       def read_all: ...
 
       # @rbs override
-      # : (Array[cache_key], **top) { (CacheKey) -> V? } -> either[Error, Array[Snapshot[V]]]
+      # : (cache_key, **top) { () -> V? } -> V?
+      def fetch: ...
+
+      # @rbs override
+      # : (Array[cache_key], **top) { (CacheKey) -> V? } -> Hash[cache_key, V]
       def fetch_all: ...
 
       # @rbs override
@@ -45,24 +47,14 @@ module TypedCache
       def key?: ...
 
       # @rbs override
-      # : -> maybe[Error]
+      # : -> void
       def clear: ...
 
-      # @rbs override
-      # : -> String
-      def store_type: ...
-
       # : (Hash[Symbol, top]) -> ActiveSupport[V]
       def with_options: (Hash[Symbol, top]) -> ActiveSupport[V]
 
       # : -> ::ActiveSupport::Cache::Store
       def raw_cache: () -> ::ActiveSupport::Cache::Store
-
-      private
-
-      # Regex patterns that match keys for this namespace (with trailing colon)
-      # : -> Array[Regexp]
-      def namespace_prefix_patterns: () -> Array[Regexp]
     end
   end
 end

data/sig/generated/typed_cache/backends/memory.rbs

@@ -1,15 +1,6 @@
 # Generated from lib/typed_cache/backends/memory.rb with RBS::Inline
 
 module TypedCache
-  class MemoryStoreRegistry
-    include Singleton
-
-    extend Forwardable
-
-    # : -> void
-    def initialize: () -> void
-  end
-
   module Backends
     # A type-safe memory store implementation with built-in namespacing
     # @rbs generic V
@@ -44,25 +35,23 @@ module TypedCache
         def expired?: () -> bool
       end
 
-      attr_reader namespace: Namespace
-
-      attr_reader ttl: Namespace
+      attr_reader ttl: Integer
 
-      attr_reader backing_store: hash_like[CacheKey, Entry[V]]
+      attr_reader backing_store: hash_like[String, Entry[V]]
 
-      # : (Namespace, shared: bool, ttl: Integer) -> void
-      def initialize: (Namespace, shared: bool, ttl: Integer) -> void
+      # : (ttl: Integer) -> void
+      def initialize: (ttl: Integer) -> void
 
       # @rbs override
-      # : (cache_key, **top) -> either[Error, Snapshot[V]]
+      # : (cache_key, **top) -> V?
       def read: ...
 
       # @rbs override
-      # : (cache_key, V, expires_in: Integer, expires_at: Time, **top) -> either[Error, Snapshot[V]]
+      # : (cache_key, V, expires_in: Integer, expires_at: Time, **top) -> V
       def write: ...
 
       # @rbs override
-      # : (cache_key) -> either[Error, Snapshot[V]]
+      # : (cache_key) -> V?
       def delete: ...
 
       # @rbs override
@@ -70,24 +59,15 @@ module TypedCache
       def key?: ...
 
       # @rbs override
-      # : -> maybe[Error]
+      # : -> void
       def clear: ...
 
       # @rbs override
-      # : -> String
-      def store_type: ...
-
-      # : -> Integer
-      def size: () -> Integer
-
-      # : -> Array[CacheKey]
-      def keys: () -> Array[CacheKey]
+      # : (cache_key, ttl: Integer, **top) { () -> V? } -> V?
+      def fetch: ...
 
       private
 
-      # : -> Hash[CacheKey, Entry[V]]
-      def namespaced_entries: () -> Hash[CacheKey, Entry[V]]
-
       # : -> void
       def purge_expired_keys: () -> void
     end

data/sig/generated/typed_cache/backends.rbs

@@ -4,7 +4,7 @@ module TypedCache
   module Backends
     # @api private
     # Backend registry using composition
-    REGISTRY: untyped
+    REGISTRY: Registry[Backend]
 
     extend Forwardable
 
@@ -12,7 +12,7 @@ module TypedCache
     # : -> Registry
     def self.registry: () -> Registry
 
-    def resolve: (Symbol, *untyped, **untyped) -> either[Error, Store[untyped]]
+    def resolve: (Symbol, *untyped, **untyped) -> either[Error, Backend[untyped]]
 
     def available: () -> Array[Symbol]
 

data/sig/generated/typed_cache/cache_builder.rbs

@@ -1,23 +1,63 @@
 # Generated from lib/typed_cache/cache_builder.rb with RBS::Inline
 
 module TypedCache
-  class CacheBuilder
-    type config = TypedCache::typed_cache_config
+  class BackendConfig < Dry::Struct
+  end
+
+  class DecoratorConfig < Dry::Struct
+  end
+
+  class CacheDefinition
+    include _CacheDefinition
 
     type instrumenter_source = :default | :dry | :rails | Instrumenter
 
-    class BackendConfig < Dry::Struct
-    end
+    attr_reader backend_config: BackendConfig?
 
-    class DecoratorConfig < Dry::Struct
-    end
+    attr_reader decorator_configs: Array[DecoratorConfig]
 
-    # @rbs (config, Registry[backend[untyped]], Registry[decorator[untyped]]) -> void
-    def initialize: (config, Registry[backend[untyped]], Registry[decorator[untyped]]) -> void
+    attr_reader instrumenter_source: instrumenter_source
 
-    # Builds the cache - the only method that can fail
-    # @rbs (?Namespace) -> either[Error, Store[V]]
-    def build: (?Namespace) -> either[Error, Store[V]]
+    # @rbs (?BackendConfig?, ?Array[DecoratorConfig], ?instrumenter_source) -> void
+    def initialize: (?BackendConfig?, ?Array[DecoratorConfig], ?instrumenter_source) -> void
+
+    # @rbs override
+    # @rbs (Symbol, *untyped, **untyped) -> self
+    def with_backend: ...
+
+    # @rbs override
+    # @rbs (Symbol, **untyped) -> self
+    def with_decorator: ...
+
+    # @rbs override
+    # @rbs (instrumenter_source) -> self
+    def with_instrumentation: ...
+  end
+
+  class CacheBuilder
+    include _CacheBuilder
+
+    include _CacheDefinition
+
+    # @rbs (?_CacheDefinition, ?Registry[backend[untyped]], ?Registry[decorator[untyped]]) -> void
+    def initialize: (?_CacheDefinition, ?Registry[backend[untyped]], ?Registry[decorator[untyped]]) -> void
+
+    # Builds the cache using the given namespace, defaulting to the root namespace
+    # @rbs (?Namespace) -> either[Error, Store[untyped]]
+    def build: (?Namespace) -> either[Error, Store[untyped]]
+
+    # @rbs (Namespace) -> Store[untyped]
+    def build!: (Namespace) -> Store[untyped]
+
+    # Constructs only a typed backend from the registry without a Store wrapper
+    # @rbs () -> either[Error, Backend[untyped]]
+    def build_backend: () -> either[Error, Backend[untyped]]
+
+    # Constructs only a typed backend from the registry without a Store wrapper,
+    # raises an error if the backend cannot be constructed
+    #
+    # @rbs () -> Backend[untyped]
+    def build_backend!: () -> Backend[untyped]
 
     # Familiar Ruby fluent interface - always succeeds
     # Invalid configurations are caught during build()
@@ -37,12 +77,13 @@ module TypedCache
     # @rbs (Namespace) -> either[Error, Store[V]]
     def validate_and_build: (Namespace) -> either[Error, Store[V]]
 
-    # @rbs (Namespace) -> either[Error, Store[V]]
-    def create_store: (Namespace) -> either[Error, Store[V]]
+    # @rbs (Namespace) -> either[Error, Backend[untyped]]
+    def create_backend: (Namespace) -> either[Error, Backend[untyped]]
 
-    # @rbs (Store[V]) -> either[Error, Store[V]]
-    def apply_decorators: (Store[V]) -> either[Error, Store[V]]
+    # @rbs (Backend[untyped]) -> either[Error, Decorator[untyped]]
+    def apply_decorators: (Backend[untyped]) -> either[Error, Decorator[untyped]]
 
-    def apply_instrumentation: (untyped store) -> untyped
+    # @rbs (Backend[untyped]) -> either[Error, Backend[untyped]]
+    def apply_instrumentation: (Backend[untyped]) -> either[Error, Backend[untyped]]
   end
 end

data/sig/generated/typed_cache/cache_ref.rbs

@@ -15,21 +15,21 @@ module TypedCache
     def initialize: (Store[V], CacheKey) -> void
 
     # Gets a value from the cache as a snapshot
-    # : -> either[Error, Snapshot[V]]
-    def read: () -> either[Error, Snapshot[V]]
+    # : -> either[Error, Snapshot[maybe[V]]]
+    def read: () -> either[Error, Snapshot[maybe[V]]]
 
     # Sets a value in the cache and returns it as an updated snapshot
     # : (V) -> either[Error, Snapshot[V]]
     def write: (V) -> either[Error, Snapshot[V]]
 
     # Deletes the value from the cache and returns the deleted value as a snapshot
-    # : -> either[Error, Snapshot[V]]
-    def delete: () -> either[Error, Snapshot[V]]
+    # : -> either[Error, maybe[V]]
+    def delete: () -> either[Error, maybe[V]]
 
     # Fetches a value from cache, computing and storing it if not found
     # The snapshot indicates whether the value came from cache or was computed
-    # : () { -> V } -> either[Error, Snapshot[V]]
-    def fetch: () { () -> V } -> either[Error, Snapshot[V]]
+    # : () { -> V? } -> either[Error, Snapshot[maybe[V]]]
+    def fetch: () { () -> V? } -> either[Error, Snapshot[maybe[V]]]
 
     # Checks if the cache contains a value for this key
     # : -> bool
@@ -43,42 +43,15 @@ module TypedCache
     # : [R] () { (V) -> R } -> either[Error, Snapshot[R]]
     def map: [R] () { (V) -> R } -> either[Error, Snapshot[R]]
 
-    # Binds over the cached value, allowing for monadic composition with snapshots
-    # : [R] () { (V) -> either[Error, R] } -> either[Error, Snapshot[R]]
-    def bind: [R] () { (V) -> either[Error, R] } -> either[Error, Snapshot[R]]
-
-    alias flat_map bind
-
     # Updates the cached value using the provided block
     # Returns the updated value as a snapshot with source=:updated
-    # : () { (V) -> V } -> either[Error, Snapshot[V]]
-    def update: () { (V) -> V } -> either[Error, Snapshot[V]]
-
-    # Returns the cached value or a default if the cache is empty/errored
-    # : (V) -> V
-    def value_or: (V) -> V
-
-    # Returns a Maybe containing the cached value, or None if not present
-    # This provides a more functional approach than value_or
-    # : -> maybe[V]
-    def value_maybe: () -> maybe[V]
+    # : () { (V) -> V? } -> either[Error, Snapshot[maybe[V]]]
+    def update: () { (V) -> V? } -> either[Error, Snapshot[maybe[V]]]
 
     # Computes and caches a value if the cache is currently empty
     # Returns existing snapshot if present, computed snapshot if cache miss, error otherwise
-    # : () { -> V } -> either[Error, Snapshot[V]]
-    def compute_if_absent: () { () -> V } -> either[Error, Snapshot[V]]
-
-    # Creates a new CacheRef with the same store but different key
-    # : [R] (String) -> CacheRef[R]
-    def with_key: [R] (String) -> CacheRef[R]
-
-    # Creates a scoped CacheRef by appending to the current key path
-    # : [R] (String) -> CacheRef[R]
-    def scope: [R] (String) -> CacheRef[R]
-
-    # Pattern matching support for Either[Error, Snapshot[V]] results
-    # : [R] (^(Error) -> R, ^(Snapshot[V]) -> R) -> R
-    def fold: [R] (^(Error) -> R, ^(Snapshot[V]) -> R) -> R
+    # : () { -> V? } -> either[Error, Snapshot[maybe[V]]]
+    def compute_if_absent: () { () -> V? } -> either[Error, Snapshot[maybe[V]]]
 
     # Convenience method to work with the snapshot directly
     # : [R] () { (Snapshot[V]) -> R } -> either[Error, R]
@@ -87,5 +60,11 @@ module TypedCache
     # Convenience method to work with just the value (losing snapshot context)
     # : [R] () { (V) -> R } -> either[Error, R]
     def with: [R] () { (V) -> R } -> either[Error, R]
+
+    # @rbs () -> String
+    def to_s: () -> String
+
+    # @rbs () -> String
+    def inspect: () -> String
   end
 end

data/sig/generated/typed_cache/decorator.rbs

@@ -7,20 +7,32 @@ module TypedCache
   module Decorator[V]
     extend Forwardable
 
-    include Store[V]
+    interface _Decorator[V]
+      def initialize: (Backend[V]) -> void
+    end
 
-    include Store::_Store[V]
+    include Backend[V]
 
-    include Store::_Decorator[V]
+    include Backend::_Backend[V]
 
-    def store: () -> Store[V]
+    include _Decorator[V]
 
     # @rbs override
-    # : (cache_key) -> either[Error, CacheRef[V]]
-    def ref: ...
+    # @rbs () -> Backend[V]
+    def backend: ...
 
     # @rbs override
     # : (self) -> void
     def initialize_copy: ...
+
+    # @rbs override
+    # @rbs () -> String
+    def to_s: ...
+
+    # @rbs override
+    # @rbs () -> String
+    def inspect: ...
   end
+
+  type decorator[V] = Decorator::_Decorator[V] & Backend[V]
 end

data/sig/generated/typed_cache/decorators/instrumented.rbs

@@ -9,24 +9,20 @@ module TypedCache
 
     extend Forwardable
 
-    attr_reader store: TypedCache::Store[V]
+    attr_reader backend: Backend[V]
 
     attr_reader instrumenter: Instrumenter
 
     # @rbs (Symbol, ?operation: String) ?{ (*untyped, **untyped) -> String } -> void
     private def self.instrument: (Symbol, ?operation: String) ?{ (*untyped, **untyped) -> String } -> void
 
-    # : (TypedCache::Store[V], instrumenter: Instrumenter) -> void
-    def initialize: (TypedCache::Store[V], instrumenter: Instrumenter) -> void
+    # : (Backend[V], instrumenter: Instrumenter) -> void
+    def initialize: (Backend[V], instrumenter: Instrumenter) -> void
 
     # @rbs override
     # : (self) -> self
     def initialize_copy: ...
 
-    # @rbs override
-    # : -> String
-    def store_type: ...
-
     # Additional methods that might exist on the wrapped store
     def respond_to_missing?: (untyped method_name, ?untyped include_private) -> untyped
 

data/sig/generated/typed_cache/decorators.rbs

@@ -16,10 +16,18 @@ module TypedCache
     # @api private
     # Default decorator set – starts with instrumentation only, but this registry
     # lets end-users register their own via `Decorators.register`.
-    REGISTRY: untyped
+    REGISTRY: Registry[Decorator]
 
     extend Forwardable
 
+    def resolve: (Symbol, *untyped, **untyped) -> either[Error, Decorator[untyped]]
+
+    def available: () -> Array[Symbol]
+
+    def register: (Symbol, Class) -> either[Error, void]
+
+    def registered?: (Symbol) -> bool
+
     # @api private
     # @rbs () -> Registry[Store[untyped]]
     def self.registry: () -> Registry[Store[untyped]]