@geekmidas/cache 0.0.2 → 0.0.4

package/dist/__tests__/memory.spec.mjs

@@ -1,5 +1,5 @@
-import { beforeEach, describe, globalExpect, it } from "../vi.DgezovHB-McgltIC5.mjs";
-import { InMemoryCache } from "../memory-YteQXj7m.mjs";
+import { InMemoryCache } from "../memory-NQi0XmZ2.mjs";
+import { beforeEach, describe, expect, it } from "vitest";
 
 //#region src/__tests__/memory.spec.ts
 describe("InMemoryCache", () => {
@@ -10,12 +10,12 @@ describe("InMemoryCache", () => {
 	describe("get", () => {
 		it("should return undefined for non-existent key", async () => {
 			const result = await cache.get("non-existent");
-			globalExpect(result).toBeUndefined();
+			expect(result).toBeUndefined();
 		});
 		it("should return value for existing key", async () => {
 			await cache.set("test-key", "test-value");
 			const result = await cache.get("test-key");
-			globalExpect(result).toBe("test-value");
+			expect(result).toBe("test-value");
 		});
 		it("should handle different data types", async () => {
 			const objectValue = {
@@ -33,17 +33,17 @@ describe("InMemoryCache", () => {
 			await cache.set("array", arrayValue);
 			await cache.set("number", numberValue);
 			await cache.set("boolean", booleanValue);
-			globalExpect(await cache.get("object")).toEqual(objectValue);
-			globalExpect(await cache.get("array")).toEqual(arrayValue);
-			globalExpect(await cache.get("number")).toBe(numberValue);
-			globalExpect(await cache.get("boolean")).toBe(booleanValue);
+			expect(await cache.get("object")).toEqual(objectValue);
+			expect(await cache.get("array")).toEqual(arrayValue);
+			expect(await cache.get("number")).toBe(numberValue);
+			expect(await cache.get("boolean")).toBe(booleanValue);
 		});
 	});
 	describe("set", () => {
 		it("should store string value", async () => {
 			await cache.set("string-key", "string-value");
 			const result = await cache.get("string-key");
-			globalExpect(result).toBe("string-value");
+			expect(result).toBe("string-value");
 		});
 		it("should store object value", async () => {
 			const value = {
@@ -52,18 +52,18 @@ describe("InMemoryCache", () => {
 			};
 			await cache.set("object-key", value);
 			const result = await cache.get("object-key");
-			globalExpect(result).toEqual(value);
+			expect(result).toEqual(value);
 		});
 		it("should overwrite existing value", async () => {
 			await cache.set("key", "initial-value");
 			await cache.set("key", "updated-value");
 			const result = await cache.get("key");
-			globalExpect(result).toBe("updated-value");
+			expect(result).toBe("updated-value");
 		});
 		it("should handle null values", async () => {
 			await cache.set("null-key", null);
 			const result = await cache.get("null-key");
-			globalExpect(result).toBeNull();
+			expect(result).toBeNull();
 		});
 	});
 	describe("delete", () => {
@@ -71,17 +71,17 @@ describe("InMemoryCache", () => {
 			await cache.set("to-delete", "value");
 			await cache.delete("to-delete");
 			const result = await cache.get("to-delete");
-			globalExpect(result).toBeUndefined();
+			expect(result).toBeUndefined();
 		});
 		it("should not throw error for non-existent key", async () => {
-			await globalExpect(cache.delete("non-existent")).resolves.not.toThrow();
+			await expect(cache.delete("non-existent")).resolves.not.toThrow();
 		});
 		it("should only delete specified key", async () => {
 			await cache.set("key1", "value1");
 			await cache.set("key2", "value2");
 			await cache.delete("key1");
-			globalExpect(await cache.get("key1")).toBeUndefined();
-			globalExpect(await cache.get("key2")).toBe("value2");
+			expect(await cache.get("key1")).toBeUndefined();
+			expect(await cache.get("key2")).toBe("value2");
 		});
 	});
 	describe("multiple operations", () => {
@@ -89,9 +89,9 @@ describe("InMemoryCache", () => {
 			await cache.set("key1", "value1");
 			await cache.set("key2", "value2");
 			await cache.set("key3", "value3");
-			globalExpect(await cache.get("key1")).toBe("value1");
-			globalExpect(await cache.get("key2")).toBe("value2");
-			globalExpect(await cache.get("key3")).toBe("value3");
+			expect(await cache.get("key1")).toBe("value1");
+			expect(await cache.get("key2")).toBe("value2");
+			expect(await cache.get("key3")).toBe("value3");
 		});
 		it("should maintain data integrity across operations", async () => {
 			const data = { count: 0 };
@@ -99,25 +99,25 @@ describe("InMemoryCache", () => {
 			const retrieved = await cache.get("counter");
 			retrieved.count = 5;
 			const original = await cache.get("counter");
-			globalExpect(original.count).toBe(5);
+			expect(original.count).toBe(5);
 		});
 	});
 	describe("edge cases", () => {
 		it("should handle empty string as key", async () => {
 			await cache.set("", "empty-key-value");
 			const result = await cache.get("");
-			globalExpect(result).toBe("empty-key-value");
+			expect(result).toBe("empty-key-value");
 		});
 		it("should handle special characters in keys", async () => {
 			const specialKey = "key!@#$%^&*()_+{}|:\"<>?[]\\;',./?`~";
 			await cache.set(specialKey, "special-value");
 			const result = await cache.get(specialKey);
-			globalExpect(result).toBe("special-value");
+			expect(result).toBe("special-value");
 		});
 		it("should handle undefined values", async () => {
 			await cache.set("undefined-key", void 0);
 			const result = await cache.get("undefined-key");
-			globalExpect(result).toBeUndefined();
+			expect(result).toBeUndefined();
 		});
 	});
 });

package/dist/__tests__/upstash.spec.cjs

@@ -1,16 +1,17 @@
+const require_chunk = require('../chunk-CUT6urMc.cjs');
 const require_upstash = require('../upstash-0RolGx7m.cjs');
-const require_vi_DgezovHB = require('../vi.DgezovHB-NqP74KGR.cjs');
+const vitest = require_chunk.__toESM(require("vitest"));
 
 //#region src/__tests__/upstash.spec.ts
-require_vi_DgezovHB.describe("UpstashCache", () => {
+(0, vitest.describe)("UpstashCache", () => {
 	let cache;
 	const testKeyPrefix = `test:${Date.now()}:`;
 	let testKeys = [];
-	require_vi_DgezovHB.beforeEach(() => {
+	(0, vitest.beforeEach)(() => {
 		cache = new require_upstash.UpstashCache("http://localhost:8079", "example_token");
 		testKeys = [];
 	});
-	require_vi_DgezovHB.afterEach(async () => {
+	(0, vitest.afterEach)(async () => {
 		for (const key of testKeys) try {
 			await cache.delete(key);
 		} catch (error) {}
@@ -20,13 +21,13 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 		testKeys.push(key);
 		return key;
 	};
-	require_vi_DgezovHB.describe("get", () => {
-		require_vi_DgezovHB.it("should return undefined for non-existent key", async () => {
+	(0, vitest.describe)("get", () => {
+		(0, vitest.it)("should return undefined for non-existent key", async () => {
 			const key = getTestKey("non-existent");
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			(0, vitest.expect)(result).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should parse and return JSON value", async () => {
+		(0, vitest.it)("should parse and return JSON value", async () => {
 			const key = getTestKey("object");
 			const testValue = {
 				id: 1,
@@ -34,30 +35,30 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			};
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(testValue);
+			(0, vitest.expect)(result).toEqual(testValue);
 		});
-		require_vi_DgezovHB.it("should handle string values", async () => {
+		(0, vitest.it)("should handle string values", async () => {
 			const key = getTestKey("string");
 			const testValue = "simple string";
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			(0, vitest.expect)(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should handle number values", async () => {
+		(0, vitest.it)("should handle number values", async () => {
 			const key = getTestKey("number");
 			const testValue = 42;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			(0, vitest.expect)(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should handle boolean values", async () => {
+		(0, vitest.it)("should handle boolean values", async () => {
 			const key = getTestKey("boolean");
 			const testValue = true;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			(0, vitest.expect)(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should handle array values", async () => {
+		(0, vitest.it)("should handle array values", async () => {
 			const key = getTestKey("array");
 			const testArray = [
 				1,
@@ -67,17 +68,17 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			];
 			await cache.set(key, testArray);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(testArray);
+			(0, vitest.expect)(result).toEqual(testArray);
 		});
-		require_vi_DgezovHB.it("should handle null values as undefined", async () => {
+		(0, vitest.it)("should handle null values as undefined", async () => {
 			const key = getTestKey("null");
 			await cache.set(key, null);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			(0, vitest.expect)(result).toBeUndefined();
 		});
 	});
-	require_vi_DgezovHB.describe("set", () => {
-		require_vi_DgezovHB.it("should store and retrieve object value", async () => {
+	(0, vitest.describe)("set", () => {
+		(0, vitest.it)("should store and retrieve object value", async () => {
 			const key = getTestKey("set-object");
 			const testValue = {
 				id: 1,
@@ -85,30 +86,30 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			};
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(testValue);
+			(0, vitest.expect)(result).toEqual(testValue);
 		});
-		require_vi_DgezovHB.it("should store and retrieve string values", async () => {
+		(0, vitest.it)("should store and retrieve string values", async () => {
 			const key = getTestKey("set-string");
 			const testValue = "test string";
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			(0, vitest.expect)(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should store and retrieve number values", async () => {
+		(0, vitest.it)("should store and retrieve number values", async () => {
 			const key = getTestKey("set-number");
 			const testValue = 42;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			(0, vitest.expect)(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should store and retrieve boolean values", async () => {
+		(0, vitest.it)("should store and retrieve boolean values", async () => {
 			const key = getTestKey("set-boolean");
 			const testValue = true;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			(0, vitest.expect)(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should store and retrieve array values", async () => {
+		(0, vitest.it)("should store and retrieve array values", async () => {
 			const key = getTestKey("set-array");
 			const testArray = [
 				1,
@@ -117,46 +118,46 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			];
 			await cache.set(key, testArray);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(testArray);
+			(0, vitest.expect)(result).toEqual(testArray);
 		});
-		require_vi_DgezovHB.it("should not store and retrieve null values", async () => {
+		(0, vitest.it)("should not store and retrieve null values", async () => {
 			const key = getTestKey("set-null");
 			await cache.set(key, null);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			(0, vitest.expect)(result).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should overwrite existing values", async () => {
+		(0, vitest.it)("should overwrite existing values", async () => {
 			const key = getTestKey("overwrite");
 			await cache.set(key, "initial");
 			await cache.set(key, "updated");
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe("updated");
+			(0, vitest.expect)(result).toBe("updated");
 		});
 	});
-	require_vi_DgezovHB.describe("delete", () => {
-		require_vi_DgezovHB.it("should delete existing key", async () => {
+	(0, vitest.describe)("delete", () => {
+		(0, vitest.it)("should delete existing key", async () => {
 			const key = getTestKey("delete-test");
 			await cache.set(key, "value-to-delete");
 			await cache.delete(key);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			(0, vitest.expect)(result).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should handle deletion of non-existent key", async () => {
+		(0, vitest.it)("should handle deletion of non-existent key", async () => {
 			const key = getTestKey("non-existent-delete");
-			await require_vi_DgezovHB.globalExpect(cache.delete(key)).resolves.not.toThrow();
+			await (0, vitest.expect)(cache.delete(key)).resolves.not.toThrow();
 		});
-		require_vi_DgezovHB.it("should only delete specified key", async () => {
+		(0, vitest.it)("should only delete specified key", async () => {
 			const key1 = getTestKey("delete-key1");
 			const key2 = getTestKey("delete-key2");
 			await cache.set(key1, "value1");
 			await cache.set(key2, "value2");
 			await cache.delete(key1);
-			require_vi_DgezovHB.globalExpect(await cache.get(key1)).toBeUndefined();
-			require_vi_DgezovHB.globalExpect(await cache.get(key2)).toBe("value2");
+			(0, vitest.expect)(await cache.get(key1)).toBeUndefined();
+			(0, vitest.expect)(await cache.get(key2)).toBe("value2");
 		});
 	});
-	require_vi_DgezovHB.describe("integration scenarios", () => {
-		require_vi_DgezovHB.it("should handle round-trip operations", async () => {
+	(0, vitest.describe)("integration scenarios", () => {
+		(0, vitest.it)("should handle round-trip operations", async () => {
 			const key = getTestKey("user-session");
 			const testData = {
 				user: {
@@ -168,9 +169,9 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			};
 			await cache.set(key, testData);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(testData);
+			(0, vitest.expect)(result).toEqual(testData);
 		});
-		require_vi_DgezovHB.it("should handle complex nested objects", async () => {
+		(0, vitest.it)("should handle complex nested objects", async () => {
 			const key = getTestKey("complex");
 			const complexObject = { level1: { level2: { level3: {
 				data: "deep nested value",
@@ -178,9 +179,9 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			} } } };
 			await cache.set(key, complexObject);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(complexObject);
+			(0, vitest.expect)(result).toEqual(complexObject);
 		});
-		require_vi_DgezovHB.it("should handle concurrent operations", async () => {
+		(0, vitest.it)("should handle concurrent operations", async () => {
 			const keys = [
 				"concurrent1",
 				"concurrent2",
@@ -193,7 +194,7 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			];
 			await Promise.all(keys.map((key, i) => cache.set(key, values[i])));
 			const results = await Promise.all(keys.map((key) => cache.get(key)));
-			require_vi_DgezovHB.globalExpect(results).toEqual(values);
+			(0, vitest.expect)(results).toEqual(values);
 		});
 	});
 });

package/dist/__tests__/upstash.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/upstash.spec.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/upstash.spec.mjs

@@ -1,5 +1,5 @@
-import { afterEach, beforeEach, describe, globalExpect, it } from "../vi.DgezovHB-McgltIC5.mjs";
-import { UpstashCache } from "../upstash-_05vyc5o.mjs";
+import { UpstashCache } from "../upstash-CTY-M8vR.mjs";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 //#region src/__tests__/upstash.spec.ts
 describe("UpstashCache", () => {
@@ -24,7 +24,7 @@ describe("UpstashCache", () => {
 		it("should return undefined for non-existent key", async () => {
 			const key = getTestKey("non-existent");
 			const result = await cache.get(key);
-			globalExpect(result).toBeUndefined();
+			expect(result).toBeUndefined();
 		});
 		it("should parse and return JSON value", async () => {
 			const key = getTestKey("object");
@@ -34,28 +34,28 @@ describe("UpstashCache", () => {
 			};
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			globalExpect(result).toEqual(testValue);
+			expect(result).toEqual(testValue);
 		});
 		it("should handle string values", async () => {
 			const key = getTestKey("string");
 			const testValue = "simple string";
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			globalExpect(result).toBe(testValue);
+			expect(result).toBe(testValue);
 		});
 		it("should handle number values", async () => {
 			const key = getTestKey("number");
 			const testValue = 42;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			globalExpect(result).toBe(testValue);
+			expect(result).toBe(testValue);
 		});
 		it("should handle boolean values", async () => {
 			const key = getTestKey("boolean");
 			const testValue = true;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			globalExpect(result).toBe(testValue);
+			expect(result).toBe(testValue);
 		});
 		it("should handle array values", async () => {
 			const key = getTestKey("array");
@@ -67,13 +67,13 @@ describe("UpstashCache", () => {
 			];
 			await cache.set(key, testArray);
 			const result = await cache.get(key);
-			globalExpect(result).toEqual(testArray);
+			expect(result).toEqual(testArray);
 		});
 		it("should handle null values as undefined", async () => {
 			const key = getTestKey("null");
 			await cache.set(key, null);
 			const result = await cache.get(key);
-			globalExpect(result).toBeUndefined();
+			expect(result).toBeUndefined();
 		});
 	});
 	describe("set", () => {
@@ -85,28 +85,28 @@ describe("UpstashCache", () => {
 			};
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			globalExpect(result).toEqual(testValue);
+			expect(result).toEqual(testValue);
 		});
 		it("should store and retrieve string values", async () => {
 			const key = getTestKey("set-string");
 			const testValue = "test string";
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			globalExpect(result).toBe(testValue);
+			expect(result).toBe(testValue);
 		});
 		it("should store and retrieve number values", async () => {
 			const key = getTestKey("set-number");
 			const testValue = 42;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			globalExpect(result).toBe(testValue);
+			expect(result).toBe(testValue);
 		});
 		it("should store and retrieve boolean values", async () => {
 			const key = getTestKey("set-boolean");
 			const testValue = true;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			globalExpect(result).toBe(testValue);
+			expect(result).toBe(testValue);
 		});
 		it("should store and retrieve array values", async () => {
 			const key = getTestKey("set-array");
@@ -117,20 +117,20 @@ describe("UpstashCache", () => {
 			];
 			await cache.set(key, testArray);
 			const result = await cache.get(key);
-			globalExpect(result).toEqual(testArray);
+			expect(result).toEqual(testArray);
 		});
 		it("should not store and retrieve null values", async () => {
 			const key = getTestKey("set-null");
 			await cache.set(key, null);
 			const result = await cache.get(key);
-			globalExpect(result).toBeUndefined();
+			expect(result).toBeUndefined();
 		});
 		it("should overwrite existing values", async () => {
 			const key = getTestKey("overwrite");
 			await cache.set(key, "initial");
 			await cache.set(key, "updated");
 			const result = await cache.get(key);
-			globalExpect(result).toBe("updated");
+			expect(result).toBe("updated");
 		});
 	});
 	describe("delete", () => {
@@ -139,11 +139,11 @@ describe("UpstashCache", () => {
 			await cache.set(key, "value-to-delete");
 			await cache.delete(key);
 			const result = await cache.get(key);
-			globalExpect(result).toBeUndefined();
+			expect(result).toBeUndefined();
 		});
 		it("should handle deletion of non-existent key", async () => {
 			const key = getTestKey("non-existent-delete");
-			await globalExpect(cache.delete(key)).resolves.not.toThrow();
+			await expect(cache.delete(key)).resolves.not.toThrow();
 		});
 		it("should only delete specified key", async () => {
 			const key1 = getTestKey("delete-key1");
@@ -151,8 +151,8 @@ describe("UpstashCache", () => {
 			await cache.set(key1, "value1");
 			await cache.set(key2, "value2");
 			await cache.delete(key1);
-			globalExpect(await cache.get(key1)).toBeUndefined();
-			globalExpect(await cache.get(key2)).toBe("value2");
+			expect(await cache.get(key1)).toBeUndefined();
+			expect(await cache.get(key2)).toBe("value2");
 		});
 	});
 	describe("integration scenarios", () => {
@@ -168,7 +168,7 @@ describe("UpstashCache", () => {
 			};
 			await cache.set(key, testData);
 			const result = await cache.get(key);
-			globalExpect(result).toEqual(testData);
+			expect(result).toEqual(testData);
 		});
 		it("should handle complex nested objects", async () => {
 			const key = getTestKey("complex");
@@ -178,7 +178,7 @@ describe("UpstashCache", () => {
 			} } } };
 			await cache.set(key, complexObject);
 			const result = await cache.get(key);
-			globalExpect(result).toEqual(complexObject);
+			expect(result).toEqual(complexObject);
 		});
 		it("should handle concurrent operations", async () => {
 			const keys = [
@@ -193,7 +193,7 @@ describe("UpstashCache", () => {
 			];
 			await Promise.all(keys.map((key, i) => cache.set(key, values[i])));
 			const results = await Promise.all(keys.map((key) => cache.get(key)));
-			globalExpect(results).toEqual(values);
+			expect(results).toEqual(values);
 		});
 	});
 });

package/dist/index-BPnJ3lrS.d.mts

@@ -0,0 +1,25 @@
+//#region src/index.d.ts
+interface Cache<T> {
+  /**
+   * Retrieves a value from the cache.
+   *
+   * @param key The key to retrieve the value for.
+   */
+  get(key: string): Promise<T | undefined>;
+  /**
+   * Sets a value in the cache.
+   *
+   * @param key The key to set the value for.
+   * @param value The value to cache.
+   * @param ttl Optional time-to-live in seconds. If not provided, the value will not expire.
+   */
+  set(key: string, value: T, ttl?: number): Promise<void>;
+  /**
+   * Deletes a value from the cache.
+   *
+   * @param key The key to delete from the cache.
+   */
+  delete(key: string): Promise<void>;
+}
+//#endregion
+export { Cache };

package/dist/index-q3xYn8_0.d.cts

@@ -0,0 +1,25 @@
+//#region src/index.d.ts
+interface Cache<T> {
+  /**
+   * Retrieves a value from the cache.
+   *
+   * @param key The key to retrieve the value for.
+   */
+  get(key: string): Promise<T | undefined>;
+  /**
+   * Sets a value in the cache.
+   *
+   * @param key The key to set the value for.
+   * @param value The value to cache.
+   * @param ttl Optional time-to-live in seconds. If not provided, the value will not expire.
+   */
+  set(key: string, value: T, ttl?: number): Promise<void>;
+  /**
+   * Deletes a value from the cache.
+   *
+   * @param key The key to delete from the cache.
+   */
+  delete(key: string): Promise<void>;
+}
+//#endregion
+export { Cache };

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+import { Cache } from "./index-q3xYn8_0.cjs";
+export { Cache };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { Cache } from "./index-BPnJ3lrS.mjs";
+export { Cache };

package/dist/memory.d.cts

@@ -0,0 +1,11 @@
+import { Cache } from "./index-q3xYn8_0.cjs";
+
+//#region src/memory.d.ts
+declare class InMemoryCache<T> implements Cache<T> {
+  private store;
+  get(key: string): Promise<T | undefined>;
+  set(key: string, value: T): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+//#endregion
+export { InMemoryCache };

package/dist/memory.d.mts

@@ -0,0 +1,11 @@
+import { Cache } from "./index-BPnJ3lrS.mjs";
+
+//#region src/memory.d.ts
+declare class InMemoryCache<T> implements Cache<T> {
+  private store;
+  get(key: string): Promise<T | undefined>;
+  set(key: string, value: T): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+//#endregion
+export { InMemoryCache };

package/dist/memory.mjs

@@ -1,3 +1,3 @@
-import { InMemoryCache } from "./memory-YteQXj7m.mjs";
+import { InMemoryCache } from "./memory-NQi0XmZ2.mjs";
 
 export { InMemoryCache };

package/dist/upstash.d.cts

@@ -0,0 +1,12 @@
+import { Cache } from "./index-q3xYn8_0.cjs";
+
+//#region src/upstash.d.ts
+declare class UpstashCache<T> implements Cache<T> {
+  private client;
+  constructor(url: string, token: string);
+  get(key: string): Promise<T | undefined>;
+  set(key: string, value: T, ttl?: number): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+//#endregion
+export { UpstashCache };

package/dist/upstash.d.mts

@@ -0,0 +1,12 @@
+import { Cache } from "./index-BPnJ3lrS.mjs";
+
+//#region src/upstash.d.ts
+declare class UpstashCache<T> implements Cache<T> {
+  private client;
+  constructor(url: string, token: string);
+  get(key: string): Promise<T | undefined>;
+  set(key: string, value: T, ttl?: number): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+//#endregion
+export { UpstashCache };