typed_cache 0.1.1 → 0.3.0

data/rbi/typed_cache/cache_key.rbi

@@ -0,0 +1,16 @@
+# typed: strict
+
+module TypedCache
+  class CacheKey
+    sealed!
+
+    sig { returns(::TypedCache::Namespace) }
+    attr_reader :namespace
+
+    sig { returns(String) }
+    attr_reader :key
+
+    sig { returns(String) }
+    def to_s; end
+  end
+end

data/rbi/typed_cache/cache_ref.rbi

@@ -0,0 +1,56 @@
+# typed: strict
+
+module TypedCache
+  class CacheRef
+    extend T::Generic
+
+    sealed!
+
+    RefType = type_member
+
+    sig { returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
+    def read; end
+
+    sig { params(value: RefType).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
+    def write(value); end
+
+    sig { returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
+    def delete; end
+
+    sig { params(block: T.proc.params(value: RefType).returns(RefType)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
+    def fetch(&block); end
+
+    sig { returns(T::Boolean) }
+    def present?; end
+
+    sig { returns(T::Boolean) }
+    def empty?; end
+
+    sig { params(block: T.proc.params(value: RefType).returns(RefType)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
+    def update(&block); end
+
+    sig { params(default: RefType).returns(RefType) }
+    def value_or(default); end
+
+    sig { returns(::TypedCache::Maybe[RefType]) }
+    def value_maybe; end
+
+    sig { params(block: T.proc.params(value: RefType).returns(RefType)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[RefType]]) }
+    def compute_if_absent(&block); end
+
+    sig { params(new_key: String).returns(::TypedCache::CacheRef[RefType]) }
+    def with_key(new_key); end
+
+    sig { params(scope_key: String).returns(::TypedCache::CacheRef[RefType]) }
+    def scope(scope_key); end
+
+    sig { type_parameters(:T).params(left_fn: T.proc.params(value: Error).returns(T.type_parameter(:T)), right_fn: T.proc.params(value: ::TypedCache::Snapshot[RefType]).returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    def fold(left_fn, right_fn); end
+
+    sig { type_parameters(:T).params(block: T.proc.params(value: ::TypedCache::Snapshot[RefType]).returns(T.type_parameter(:T))).returns(::TypedCache::Either[Error, T.type_parameter(:T)]) }
+    def with_snapshot(&block); end
+
+    sig { type_parameters(:T).params(block: T.proc.params(value: RefType).returns(T.type_parameter(:T))).returns(::TypedCache::Either[Error, T.type_parameter(:T)]) }
+    def with(&block); end
+  end
+end

data/rbi/typed_cache/decorator.rbi

@@ -0,0 +1,67 @@
+# typed: strict
+
+module TypedCache
+  module Decorator
+    extend T::Generic
+
+    include ::TypedCache::Store
+
+    abstract!
+
+    CachedType = type_member
+
+    sig { params(store: ::TypedCache::Store[CachedType]).void }
+    def initialize(store); end
+
+    sig { overridable.returns(::TypedCache::Store[CachedType]) }
+    def store; end
+
+    sig(:final) { params(key: T.any(String, ::TypedCache::CacheKey)).returns(::TypedCache::CacheRef[CachedType]) }
+    def ref(key); end
+
+    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
+    def read(key); end
+
+    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey), value: CachedType).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
+    def write(key, value); end
+
+    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
+    def delete(key); end
+
+    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey)).returns(T::Boolean) }
+    def key?(key); end
+
+    sig { overridable.params(key: T.any(String, ::TypedCache::CacheKey), block: T.proc.params(value: CachedType).returns(CachedType)).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
+    def fetch(key, &block); end
+
+    sig { overridable.params(keys: T::Array[T.any(String, ::TypedCache::CacheKey)]).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
+    def read_all(keys); end
+
+    sig { overridable.params(keys: T::Array[T.any(String, ::TypedCache::CacheKey)], block: T.proc.params(key: T.any(String, ::TypedCache::CacheKey)).returns(CachedType)).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
+    def fetch_all(keys, &block); end
+
+    sig { overridable.params(values: T::Hash[T.any(String, ::TypedCache::CacheKey), CachedType]).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
+    def write_all(values); end
+
+    sig { overridable.void }
+    def clear; end
+
+    sig(:final) { returns(::TypedCache::Namespace) }
+    def namespace; end
+
+    sig(:final) { params(namespace: ::TypedCache::Namespace).returns(::TypedCache::Store[CachedType]) }
+    def with_namespace(namespace); end
+
+    sig { abstract.returns(String) }
+    def store_type; end
+
+    sig { overridable.params(other: T.self_type).void }
+    def initialize_copy(other); end
+
+    sig(:final) { params(key: T.any(String, ::TypedCache::CacheKey)).returns(::TypedCache::CacheKey) }
+    def namespaced_key(key); end
+
+    sig { overridable.returns(::TypedCache::Instrumenter) }
+    def instrumenter; end
+  end
+end

data/rbi/typed_cache/decorators/instrumented.rbi

@@ -0,0 +1,13 @@
+# typed: strict
+
+module TypedCache
+  module Decorators
+    module Instrumented
+      extend T::Generic
+
+      include ::TypedCache::Decorator
+
+      CachedType = type_member
+    end
+  end
+end

data/rbi/typed_cache/decorators.rbi

@@ -0,0 +1,19 @@
+# typed: strict
+
+module TypedCache
+  module Decorators
+    class << self
+      sig { params(name: Symbol, klass: T::Class[::TypedCache::Decorator[T.anything]]).returns(T.self_type) }
+      def register(name, klass); end
+
+      sig { params(name: Symbol, args: T::Array[T.anything], options: T::Hash[Symbol, T.anything]).returns(T.self_type) }
+      def resolve(name, *args, **options); end
+
+      sig { returns(T::Array[T::Class[::TypedCache::Decorator[T.anything]]]) }
+      def available; end
+
+      sig { params(name: Symbol).returns(T::Boolean) }
+      def registered?(name); end
+    end
+  end
+end

data/rbi/typed_cache/either.rbi

@@ -0,0 +1,122 @@
+# typed: strict
+
+module TypedCache
+  module Either
+    extend T::Generic
+    include Kernel
+
+    mixes_in_class_methods(T::Generic)
+
+    sealed!
+    interface!
+
+    L = type_member(:out)
+    R = type_member(:out)
+
+    interface!
+
+    sig { abstract.returns(T::Boolean) }
+    def left?; end
+
+    sig { abstract.returns(T::Boolean) }
+    def right?; end
+
+    sig { abstract.type_parameters(:T).params(block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(::TypedCache::Either[L, T.type_parameter(:T)]) }
+    def map(&block); end
+
+    sig { abstract.type_parameters(:T).params(block: T.proc.params(value: L).returns(T.type_parameter(:T))).returns(::TypedCache::Either[T.type_parameter(:T), R]) }
+    def map_left(&block); end
+
+    sig { abstract.type_parameters(:E, :R2).params(block: T.proc.params(value: R).returns(::TypedCache::Either[T.type_parameter(:E), T.type_parameter(:R2)])).returns(::TypedCache::Either[T.type_parameter(:E), T.type_parameter(:R2)]) }
+    def bind(&block); end
+
+    sig { abstract.type_parameters(:T).params(left_block: T.proc.params(value: L).returns(T.type_parameter(:T)), right_block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    def fold(left_block, right_block); end
+
+    sig { abstract.params(block: T.proc.params(value: L).void).returns(R) }
+    def right_or_else(&block); end
+
+    sig { abstract.returns(R) }
+    def right_or_raise!; end
+  end
+
+  class Left
+    sealed!
+
+    include ::TypedCache::Either
+    extend T::Generic
+
+    L = type_member(:out)
+    R = type_member(:out) { { fixed: T.noreturn } }
+
+    sig { override.returns(TrueClass) }
+    def left?; end
+
+    sig { override.returns(FalseClass) }
+    def right?; end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(T.self_type) }
+    def map(&block); end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: L).returns(T.type_parameter(:T))).returns(Left[T.type_parameter(:T)]) }
+    def map_left(&block); end
+
+    sig { override.type_parameters(:E, :R2).params(block: T.proc.params(value: R).returns(::TypedCache::Either[T.type_parameter(:E), T.type_parameter(:R2)])).returns(T.self_type) }
+    def bind(&block); end
+
+    sig { override.type_parameters(:T).params(left_block: T.proc.params(value: L).returns(T.type_parameter(:T)), right_block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    def fold(left_block, right_block); end
+
+    sig { returns(L) }
+    def value; end
+
+    sig { returns(L) }
+    def error; end
+
+    sig { params(block: T.proc.params(value: L).void).returns(R) }
+    def right_or_else(&block); end
+
+    sig { returns(T.noreturn) }
+    def right_or_raise!; end
+  end
+
+  class Right
+    sealed!
+
+    include ::TypedCache::Either
+    extend T::Generic
+
+    L = type_member(:out) { { fixed: T.noreturn } }
+    R = type_member(:out)
+
+    sig { override.returns(FalseClass) }
+    def left?; end
+
+    sig { override.returns(TrueClass) }
+    def right?; end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(Right[T.type_parameter(:T)]) }
+    def map(&block); end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: L).returns(T.type_parameter(:T))).returns(T.self_type) }
+    def map_left(&block); end
+
+    sig { override.type_parameters(:E, :R2).params(block: T.proc.params(value: R).returns(::TypedCache::Either[T.type_parameter(:E), T.type_parameter(:R2)])).returns(::TypedCache::Either[T.type_parameter(:E), T.type_parameter(:R2)]) }
+    def bind(&block); end
+
+    sig { override.type_parameters(:T).params(left_block: T.proc.params(value: L).returns(T.type_parameter(:T)), right_block: T.proc.params(value: R).returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    def fold(left_block, right_block); end
+
+    sig { returns(R) }
+    def value; end
+
+    sig { returns(R) }
+    def result; end
+
+    sig { params(block: T.proc.params(value: T.anything).void).returns(R) }
+    def right_or_else(&block); end
+
+    sig { returns(R) }
+    def right_or_raise!; end
+  end
+end

data/rbi/typed_cache/errors.rbi

@@ -0,0 +1,20 @@
+# typed: strict
+
+module TypedCache
+  class Error < StandardError; end
+
+  class StoreError < ::TypedCache::Error
+    sig { params(operation: Symbol, key: ::TypedCache::CacheKey, message: String, original_error: T.nilable(Error)).void }
+    def initialize(operation, key, message, original_error = nil); end
+  end
+
+  class TypeError < ::TypedCache::Error
+    sig { params(expected_type: String, actual_type: String, value: T.untyped, message: String).void }
+    def initialize(expected_type, actual_type, value, message); end
+  end
+
+  class CacheMissError < ::TypedCache::Error
+    sig { params(key: ::TypedCache::CacheKey).void }
+    def initialize(key); end
+  end
+end

data/rbi/typed_cache/instrumenter.rbi

@@ -0,0 +1,45 @@
+# typed: strict
+
+module TypedCache
+  module Instrumenter
+    abstract!
+
+    sig do
+      abstract.type_parameters(:R)
+        .params(
+          event_name: String,
+          key: String,
+          payload: T::Hash[Symbol, T.untyped],
+          blk: T.proc.returns(T.type_parameter(:R)),
+        ).returns(T.type_parameter(:R))
+    end
+    def instrument(event_name, key, **payload, &blk); end
+
+    sig do
+      abstract.type_parameters(:R)
+        .params(
+          event_name: String,
+          filters: T::Hash[Symbol, T.untyped],
+          blk: T.proc.void,
+        ).returns(T.type_parameter(:R))
+    end
+    def subscribe(event_name, **filters, &blk); end
+
+    sig { overridable.returns(String) }
+    def namespace; end
+
+    sig { overridable.returns(T::Boolean) }
+    def enabled?; end
+
+    private
+
+    sig { overridable.params(operation: String, key: String, payload: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    def build_payload(operation, key, **payload); end
+
+    sig(:final) { params(operation: String).returns(String) }
+    def event_name(operation); end
+
+    sig(:final) { returns(::TypedCache::Private::Configuration::Instrumentation) }
+    def config; end
+  end
+end

data/rbi/typed_cache/instrumenters/mixins/namedspaced_singleton.rbi

@@ -0,0 +1,33 @@
+# typed: strict
+
+module TypedCache
+  module Instrumenters
+    module Mixins
+      module NamedspacedSingleton
+        requires_ancestor { ::TypedCache::Instrumenter }
+
+        class << self
+          sig { returns(T::Array[T::Class[T.all(::TypedCache::Instrumenter, ::TypedCache::Instrumenters::Mixins::NamedspacedSingleton)]]) }
+          def all; end
+        end
+
+        sig { params(namespace: ::TypedCache::Namespace).void }
+        def initialize(namespace); end
+
+        sig { returns(::TypedCache::Namespace) }
+        def namespace; end
+
+        module ClassMethods
+          sig { params(namespace: ::TypedCache::Namespace).returns(T::Class[T.all(::TypedCache::Instrumenter, ::TypedCache::Instrumenters::Mixins::NamedspacedSingleton)]) }
+          def new(namespace: T.unsafe(nil)); end
+
+          sig { params(namespace: ::TypedCache::Namespace).returns(T::Class[T.all(::TypedCache::Instrumenter, ::TypedCache::Instrumenters::Mixins::NamedspacedSingleton)]) }
+          def get(namespace); end
+
+          sig { void }
+          def clear_namespace_cache; end
+        end
+      end
+    end
+  end
+end

data/rbi/typed_cache/instrumenters.rbi

@@ -0,0 +1,19 @@
+# typed: strict
+
+module TypedCache
+  module Instrumenters
+    class << self
+      sig { params(name: Symbol, klass: T::Class[::TypedCache::Instrumenter]).returns(T.self_type) }
+      def register(name, klass); end
+
+      sig { params(name: Symbol, args: T::Array[T.anything], options: T::Hash[Symbol, T.anything]).returns(T.self_type) }
+      def resolve(name, *args, **options); end
+
+      sig { returns(T::Array[T::Class[::TypedCache::Instrumenter]]) }
+      def available; end
+
+      sig { params(name: Symbol).returns(T::Boolean) }
+      def registered?(name); end
+    end
+  end
+end

data/rbi/typed_cache/maybe.rbi

@@ -0,0 +1,108 @@
+# typed: strict
+
+module TypedCache
+  module Maybe
+    include Kernel
+    extend T::Generic
+
+    mixes_in_class_methods(T::Generic)
+
+    sealed!
+    interface!
+
+    V = type_member(:out)
+
+    sig { abstract.returns(T::Boolean) }
+    def some?; end
+
+    sig { abstract.returns(T::Boolean) }
+    def nothing?; end
+
+    sig { abstract.type_parameters(:T).params(block: T.proc.params(value: V).returns(T.type_parameter(:T))).returns(::TypedCache::Maybe[T.type_parameter(:T)]) }
+    def map(&block); end
+
+    sig { abstract.type_parameters(:T).params(block: T.proc.params(value: V).returns(::TypedCache::Maybe[T.type_parameter(:T)])).returns(::TypedCache::Maybe[T.type_parameter(:T)]) }
+    def bind(&block); end
+
+    alias flat_map bind
+
+    sig { abstract.type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.any(T.type_parameter(:T), V)) }
+    def value_or_else(&block); end
+
+    sig { abstract.type_parameters(:T).params(value: T.type_parameter(:T)).returns(T.any(T.type_parameter(:T), V)) }
+    def value_or(value); end
+
+    sig { abstract.returns(V) }
+    def value_or_raise!; end
+
+    class << self
+      sig { type_parameters(:T).params(value: T.type_parameter(:T)).returns(::TypedCache::Some[T.type_parameter(:T)]) }
+      def some(value); end
+
+      sig { returns(::TypedCache::Nothing) }
+      def none; end
+
+      sig { params(value: NilClass).returns(::TypedCache::Nothing) }
+      sig { params(value: ::TypedCache::Nothing).returns(::TypedCache::Nothing) }
+      sig { type_parameters(:T).params(value: ::TypedCache::Some[T.type_parameter(:T)]).returns(::TypedCache::Some[T.type_parameter(:T)]) }
+      sig { type_parameters(:T).params(value: T.type_parameter(:T)).returns(::TypedCache::Some[T.type_parameter(:T)]) }
+      def wrap(value); end
+
+      alias [] some
+    end
+  end
+
+  class Some
+    sealed!
+
+    include ::TypedCache::Maybe
+    extend T::Generic
+
+    V = type_member(:out)
+
+    sig { override.returns(TrueClass) }
+    def some?; end
+
+    sig { override.returns(FalseClass) }
+    def nothing?; end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: V).returns(T.type_parameter(:T))).returns(Some[T.type_parameter(:T)]) }
+    def map(&block); end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: V).returns(::TypedCache::Maybe[T.type_parameter(:T)])).returns(::TypedCache::Maybe[T.type_parameter(:T)]) }
+    def bind(&block); end
+
+    sig { override.type_parameters(:T).params(value: T.type_parameter(:T)).returns(V) }
+    def value_or(value); end
+
+    sig { override.returns(V) }
+    def value_or_raise!; end
+  end
+
+  class Nothing
+    sealed!
+
+    include ::TypedCache::Maybe
+    extend T::Generic
+
+    V = type_member(:out) { { fixed: T.noreturn } }
+
+    sig { override.returns(FalseClass) }
+    def some?; end
+
+    sig { override.returns(TrueClass) }
+    def nothing?; end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: V).returns(T.type_parameter(:T))).returns(T.self_type) }
+    def map(&block); end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: V).returns(::TypedCache::Maybe[T.type_parameter(:T)])).returns(T.self_type) }
+    def bind(&block); end
+
+    sig { override.type_parameters(:T).params(value: T.type_parameter(:T)).returns(T.type_parameter(:T)) }
+    def value_or(value); end
+
+    sig { override.returns(T.noreturn) }
+    def value_or_raise!; end
+  end
+end

data/rbi/typed_cache/namespace.rbi

@@ -0,0 +1,30 @@
+# typed: strict
+
+module TypedCache
+  class Namespace
+    sealed!
+
+    class << self
+      sig { returns(T.attached_class) }
+      def root; end
+
+      sig { params(namespace: String, namespaces: String).returns(T.attached_class) }
+      def at(namespace, *namespaces); end
+    end
+
+    sig { params(namespace: String, key_factory: T.nilable(T.proc.params(namespace: ::TypedCache::Namespace, key: String).returns(::TypedCache::CacheKey))).returns(::TypedCache::Namespace) }
+    def nested(namespace, &key_factory); end
+
+    sig { params(namespaces: String, key_factory: T.nilable(T.proc.params(namespace: ::TypedCache::Namespace, key: String).returns(::TypedCache::CacheKey))).returns(::TypedCache::Namespace) }
+    def join(*namespaces, &key_factory); end
+
+    sig { returns(::TypedCache::Namespace) }
+    def parent_namespace; end
+
+    sig { params(key: String).returns(::TypedCache::CacheKey) }
+    def key(key); end
+
+    sig { returns(String) }
+    def to_s; end
+  end
+end

data/rbi/typed_cache/snapshot.rbi

@@ -0,0 +1,54 @@
+# typed: strict
+
+module TypedCache
+  class Snapshot
+    extend T::Generic
+
+    sealed!
+
+    ValueType = type_member(:out)
+
+    sig { returns(::TypedCache::CacheKey) }
+    def key; end
+
+    sig { returns(ValueType) }
+    def value; end
+
+    sig { returns(Time) }
+    def retrieved_at; end
+
+    sig { returns(Symbol) }
+    def source; end
+
+    sig { returns(Float) }
+    def age; end
+
+    sig { returns(T::Boolean) }
+    def from_cache?; end
+
+    sig { returns(T::Boolean) }
+    def computed?; end
+
+    sig { returns(T::Boolean) }
+    def updated?; end
+
+    sig { type_parameters(:T).params(block: T.proc.params(value: ValueType).returns(T.type_parameter(:T))).returns(::TypedCache::Snapshot[T.type_parameter(:T)]) }
+    def map(&block); end
+
+    sig { type_parameters(:T).params(block: T.proc.params(value: ValueType).returns(::TypedCache::Either[Error, T.type_parameter(:T)])).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[T.type_parameter(:T)]]) }
+    def bind(&block); end
+
+    alias flat_map bind
+
+    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
+
+      sig { type_parameters(:T).params(key: ::TypedCache::CacheKey, value: T.type_parameter(:T)).returns(::TypedCache::Snapshot[T.type_parameter(:T)]) }
+      def computed(key, value); end
+
+      sig { type_parameters(:T).params(key: ::TypedCache::CacheKey, value: T.type_parameter(:T)).returns(::TypedCache::Snapshot[T.type_parameter(:T)]) }
+      def updated(key, value); end
+    end
+  end
+end

data/rbi/typed_cache/store.rbi

@@ -0,0 +1,71 @@
+# typed: strict
+
+module TypedCache
+  module Store
+    extend T::Generic
+
+    abstract!
+
+    CachedType = type_member
+
+    Error = T.type_alias { TypedCache::Error }
+    Key = T.type_alias { T.any(String, ::TypedCache::CacheKey) }
+    private_constant :Error, :Key
+
+    sig { params(key: Key).returns(::TypedCache::Either[Error, CachedType]) }
+    def read(key); end
+
+    sig { params(keys: T::Array[Key]).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
+    def read_all(keys); end
+
+    sig { params(key: Key, value: CachedType).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
+    def write(key, value); end
+
+    sig { params(values: T::Hash[Key, CachedType]).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
+    def write_all(values); end
+
+    sig { params(key: Key).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
+    def delete(key); end
+
+    sig { params(key: Key).returns(::TypedCache::CacheRef[CachedType]) }
+    def ref(key); end
+
+    sig { void }
+    def clear; end
+
+    sig { params(key: Key).returns(T::Boolean) }
+    def key?(key); end
+
+    sig { params(key: Key, block: T.proc.returns(T.nilable(CachedType))).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[::TypedCache::Maybe[CachedType]]]) }
+    def fetch(key, &block); end
+
+    sig { params(keys: T::Array[Key], block: T.proc.params(key: ::TypedCache::CacheKey).returns(T.nilable(CachedType))).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
+    def fetch_all(keys, &block); end
+
+    sig { returns(::TypedCache::Namespace) }
+    def namespace; end
+
+    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
+  end
+end

data/rbi/typed_cache/version.rbi

@@ -0,0 +1,5 @@
+# typed: strict
+
+module TypedCache
+  VERSION = T.let(T.unsafe(nil), String)
+end