From a7e0ae3f745cf9b8e98dfc637f5b3968c1414807 Mon Sep 17 00:00:00 2001
From: schplitt <schplitt.contact@gmail.com>
Date: Fri, 22 Aug 2025 19:09:49 +0200
Subject: [PATCH 01/10] feat(drivers): add type generics to support strongly
 typed options of getters and setters

---
 src/drivers/utils/index.ts | 17 ++++++----
 src/storage.ts             | 10 +++---
 src/types.ts               | 63 +++++++++++++++++++++-----------------
 3 files changed, 51 insertions(+), 39 deletions(-)

diff --git a/src/drivers/utils/index.ts b/src/drivers/utils/index.ts
index 16e584a3a..2e1230229 100644
--- a/src/drivers/utils/index.ts
+++ b/src/drivers/utils/index.ts
@@ -1,13 +1,18 @@
-import type { Driver } from "../..";
+import type { Driver, TransactionOptions } from "../..";
 
-type DriverFactory<OptionsT, InstanceT> = (
+type DriverFactory<OptionsT, InstanceT, SetItemOptionsT, GetItemOptionsT> = (
   opts: OptionsT
-) => Driver<OptionsT, InstanceT>;
+) => Driver<OptionsT, InstanceT, SetItemOptionsT, GetItemOptionsT>;
 interface ErrorOptions {}
 
-export function defineDriver<OptionsT = any, InstanceT = never>(
-  factory: DriverFactory<OptionsT, InstanceT>
-): DriverFactory<OptionsT, InstanceT> {
+export function defineDriver<
+  OptionsT = any,
+  InstanceT = never,
+  SetItemOptionsT = TransactionOptions,
+  GetItemOptionsT = TransactionOptions,
+>(
+  factory: DriverFactory<OptionsT, InstanceT, SetItemOptionsT, GetItemOptionsT>
+): DriverFactory<OptionsT, InstanceT, SetItemOptionsT, GetItemOptionsT> {
   return factory;
 }
 
diff --git a/src/storage.ts b/src/storage.ts
index eb6578471..9ea66820f 100644
--- a/src/storage.ts
+++ b/src/storage.ts
@@ -26,13 +26,13 @@ interface StorageCTX {
   watchListeners: ((event: WatchEvent, key: string) => void)[];
 }
 
-export interface CreateStorageOptions {
-  driver?: Driver;
+export interface CreateStorageOptions<DriverT extends Driver = Driver> {
+  driver?: DriverT;
 }
 
-export function createStorage<T extends StorageValue>(
-  options: CreateStorageOptions = {}
-): Storage<T> {
+export function createStorage<T extends StorageValue, DriverT extends Driver = Driver>(
+  options: CreateStorageOptions<DriverT> = {}
+): Storage<T, DriverT> {
   const context: StorageCTX = {
     mounts: { "": options.driver || memory() },
     mountpoints: [""],
diff --git a/src/types.ts b/src/types.ts
index d347dbd06..8a636ed29 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -15,7 +15,6 @@ export interface StorageMeta {
   [key: string]: StorageValue | Date | undefined;
 }
 
-// TODO: type ttl
 export type TransactionOptions = Record<string, any>;
 
 export type GetKeysOptions = TransactionOptions & {
@@ -27,46 +26,48 @@ export interface DriverFlags {
   ttl?: boolean;
 }
 
-export interface Driver<OptionsT = any, InstanceT = any> {
+export interface Driver<
+  OptionsT = any,
+  InstanceT = any,
+  SetItemOptionsT = TransactionOptions,
+  GetItemOptionsT = TransactionOptions,
+> {
   name?: string;
   flags?: DriverFlags;
   options?: OptionsT;
   getInstance?: () => InstanceT;
-  hasItem: (key: string, opts: TransactionOptions) => MaybePromise<boolean>;
-  getItem: (
-    key: string,
-    opts?: TransactionOptions
-  ) => MaybePromise<StorageValue>;
+  hasItem: (key: string, opts: GetItemOptionsT) => MaybePromise<boolean>;
+  getItem: (key: string, opts?: GetItemOptionsT) => MaybePromise<StorageValue>;
   /** @experimental */
   getItems?: (
-    items: { key: string; options?: TransactionOptions }[],
-    commonOptions?: TransactionOptions
+    items: { key: string; options?: GetItemOptionsT }[],
+    commonOptions?: GetItemOptionsT
   ) => MaybePromise<{ key: string; value: StorageValue }[]>;
   /** @experimental */
-  getItemRaw?: (key: string, opts: TransactionOptions) => MaybePromise<unknown>;
+  getItemRaw?: (key: string, opts: GetItemOptionsT) => MaybePromise<unknown>;
   setItem?: (
     key: string,
     value: string,
-    opts: TransactionOptions
+    opts: SetItemOptionsT
   ) => MaybePromise<void>;
   /** @experimental */
   setItems?: (
-    items: { key: string; value: string; options?: TransactionOptions }[],
-    commonOptions?: TransactionOptions
+    items: { key: string; value: string; options?: SetItemOptionsT }[],
+    commonOptions?: SetItemOptionsT
   ) => MaybePromise<void>;
   /** @experimental */
   setItemRaw?: (
     key: string,
     value: any,
-    opts: TransactionOptions
+    opts: SetItemOptionsT
   ) => MaybePromise<void>;
-  removeItem?: (key: string, opts: TransactionOptions) => MaybePromise<void>;
+  removeItem?: (key: string, opts: GetItemOptionsT) => MaybePromise<void>;
   getMeta?: (
     key: string,
-    opts: TransactionOptions
+    opts: GetItemOptionsT
   ) => MaybePromise<StorageMeta | null>;
   getKeys: (base: string, opts: GetKeysOptions) => MaybePromise<string[]>;
-  clear?: (base: string, opts: TransactionOptions) => MaybePromise<void>;
+  clear?: (base: string, opts: GetItemOptionsT) => MaybePromise<void>;
   dispose?: () => MaybePromise<void>;
   watch?: (callback: WatchCallback) => MaybePromise<Unwatch>;
 }
@@ -83,7 +84,13 @@ type StorageItemType<T, K> = K extends keyof StorageItemMap<T>
     ? StorageValue
     : T;
 
-export interface Storage<T extends StorageValue = StorageValue> {
+type StorageSetOptions<DriverT extends Driver> = DriverT extends Driver<any, any, infer SetItemOptionsT>
+  ? SetItemOptionsT : never
+
+type StorageGetOptions<DriverT extends Driver> = DriverT extends Driver<any, any, any, infer GetItemOptionsT>
+  ? GetItemOptionsT : never
+
+export interface Storage<T extends StorageValue = StorageValue, DriverT extends Driver = Driver> {
   // Item
   hasItem<
     U extends Extract<T, StorageDefinition>,
@@ -99,22 +106,22 @@ export interface Storage<T extends StorageValue = StorageValue> {
     K extends string & keyof StorageItemMap<U>,
   >(
     key: K,
-    ops?: TransactionOptions
+    ops?: StorageGetOptions<DriverT>
   ): Promise<StorageItemType<T, K> | null>;
   getItem<R = StorageItemType<T, string>>(
     key: string,
-    opts?: TransactionOptions
+    opts?: StorageGetOptions<DriverT>
   ): Promise<R | null>;
 
   /** @experimental */
   getItems: <U extends T>(
-    items: (string | { key: string; options?: TransactionOptions })[],
-    commonOptions?: TransactionOptions
+    items: (string | { key: string; options?: StorageGetOptions<DriverT> })[],
+    commonOptions?: StorageGetOptions<DriverT>
   ) => Promise<{ key: string; value: U }[]>;
   /** @experimental See https://github.com/unjs/unstorage/issues/142 */
   getItemRaw: <T = any>(
     key: string,
-    opts?: TransactionOptions
+    opts?: StorageGetOptions<DriverT>
   ) => Promise<MaybeDefined<T> | null>;
 
   setItem<
@@ -123,24 +130,24 @@ export interface Storage<T extends StorageValue = StorageValue> {
   >(
     key: K,
     value: StorageItemType<T, K>,
-    opts?: TransactionOptions
+    opts?: StorageSetOptions<DriverT>
   ): Promise<void>;
   setItem<U extends T>(
     key: string,
     value: U,
-    opts?: TransactionOptions
+    opts?: StorageSetOptions<DriverT>
   ): Promise<void>;
 
   /** @experimental */
   setItems: <U extends T>(
-    items: { key: string; value: U; options?: TransactionOptions }[],
-    commonOptions?: TransactionOptions
+    items: { key: string; value: U; options?: StorageSetOptions<DriverT> }[],
+    commonOptions?: StorageSetOptions<DriverT>
   ) => Promise<void>;
   /** @experimental See https://github.com/unjs/unstorage/issues/142 */
   setItemRaw: <T = any>(
     key: string,
     value: MaybeDefined<T>,
-    opts?: TransactionOptions
+    opts?: StorageSetOptions<DriverT>
   ) => Promise<void>;
 
   removeItem<

From 2c0878a80573bfa7da963c62ee3b840763928f3a Mon Sep 17 00:00:00 2001
From: schplitt <schplitt.contact@gmail.com>
Date: Fri, 22 Aug 2025 19:55:15 +0200
Subject: [PATCH 02/10] refactor(types): unify transaction options handling in
 driver interfaces to support all methods

---
 src/drivers/utils/index.ts |  13 +++--
 src/types.ts               | 102 ++++++++++++++++++++-----------------
 2 files changed, 62 insertions(+), 53 deletions(-)

diff --git a/src/drivers/utils/index.ts b/src/drivers/utils/index.ts
index 2e1230229..2dded895b 100644
--- a/src/drivers/utils/index.ts
+++ b/src/drivers/utils/index.ts
@@ -1,18 +1,17 @@
-import type { Driver, TransactionOptions } from "../..";
+import type { Driver, TransactionOpts } from "../..";
 
-type DriverFactory<OptionsT, InstanceT, SetItemOptionsT, GetItemOptionsT> = (
+type DriverFactory<OptionsT, InstanceT, TransactionOptsT extends TransactionOpts> = (
   opts: OptionsT
-) => Driver<OptionsT, InstanceT, SetItemOptionsT, GetItemOptionsT>;
+) => Driver<OptionsT, InstanceT, TransactionOptsT>;
 interface ErrorOptions {}
 
 export function defineDriver<
   OptionsT = any,
   InstanceT = never,
-  SetItemOptionsT = TransactionOptions,
-  GetItemOptionsT = TransactionOptions,
+  TransactionOptsT extends TransactionOpts = TransactionOpts
 >(
-  factory: DriverFactory<OptionsT, InstanceT, SetItemOptionsT, GetItemOptionsT>
-): DriverFactory<OptionsT, InstanceT, SetItemOptionsT, GetItemOptionsT> {
+  factory: DriverFactory<OptionsT, InstanceT, TransactionOptsT>
+): DriverFactory<OptionsT, InstanceT, TransactionOptsT> {
   return factory;
 }
 
diff --git a/src/types.ts b/src/types.ts
index 8a636ed29..a536d65d5 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -17,57 +17,62 @@ export interface StorageMeta {
 
 export type TransactionOptions = Record<string, any>;
 
-export type GetKeysOptions = TransactionOptions & {
-  maxDepth?: number;
-};
+
 
 export interface DriverFlags {
   maxDepth?: boolean;
   ttl?: boolean;
 }
 
+export type TransactionOpts<GetOptionsT = TransactionOptions, SetOptionsT = TransactionOptions, HasOptionsT = TransactionOptions, RemoveOptionsT = TransactionOptions, GetKeysOptionsT = TransactionOptions> = {
+  getOptions?: GetOptionsT;
+  setOptions?: SetOptionsT;
+  hasOptions?: HasOptionsT;
+  removeOptions?: RemoveOptionsT;
+  getKeysOptions?: GetKeysOptionsT;
+}
+
 export interface Driver<
   OptionsT = any,
   InstanceT = any,
-  SetItemOptionsT = TransactionOptions,
-  GetItemOptionsT = TransactionOptions,
+  optionsT extends TransactionOpts = TransactionOpts
 > {
   name?: string;
   flags?: DriverFlags;
   options?: OptionsT;
   getInstance?: () => InstanceT;
-  hasItem: (key: string, opts: GetItemOptionsT) => MaybePromise<boolean>;
-  getItem: (key: string, opts?: GetItemOptionsT) => MaybePromise<StorageValue>;
+  hasItem: (key: string, opts: optionsT["hasOptions"]) => MaybePromise<boolean>;
+  getItem: (key: string, opts?: optionsT["getOptions"]) => MaybePromise<StorageValue>;
   /** @experimental */
   getItems?: (
-    items: { key: string; options?: GetItemOptionsT }[],
-    commonOptions?: GetItemOptionsT
+    items: { key: string; options?: optionsT["getOptions"] }[],
+    commonOptions?: optionsT["getOptions"]
   ) => MaybePromise<{ key: string; value: StorageValue }[]>;
   /** @experimental */
-  getItemRaw?: (key: string, opts: GetItemOptionsT) => MaybePromise<unknown>;
+  getItemRaw?: (key: string, opts: optionsT["getOptions"]) => MaybePromise<unknown>;
   setItem?: (
     key: string,
     value: string,
-    opts: SetItemOptionsT
+    opts: optionsT["setOptions"]
   ) => MaybePromise<void>;
   /** @experimental */
   setItems?: (
-    items: { key: string; value: string; options?: SetItemOptionsT }[],
-    commonOptions?: SetItemOptionsT
+    items: { key: string; value: string; options?: optionsT["setOptions"] }[],
+    commonOptions?: optionsT["setOptions"]
   ) => MaybePromise<void>;
   /** @experimental */
   setItemRaw?: (
     key: string,
     value: any,
-    opts: SetItemOptionsT
+    opts: optionsT["setOptions"]
   ) => MaybePromise<void>;
-  removeItem?: (key: string, opts: GetItemOptionsT) => MaybePromise<void>;
+  removeItem?: (key: string, opts: optionsT["removeOptions"]) => MaybePromise<void>;
   getMeta?: (
     key: string,
-    opts: GetItemOptionsT
+    opts: optionsT["getOptions"]
   ) => MaybePromise<StorageMeta | null>;
-  getKeys: (base: string, opts: GetKeysOptions) => MaybePromise<string[]>;
-  clear?: (base: string, opts: GetItemOptionsT) => MaybePromise<void>;
+  getKeys: (base: string, opts: optionsT["getKeysOptions"]) => MaybePromise<string[]>;
+  clear?: (base: string, opts: optionsT["removeOptions"]) => MaybePromise<void>;
   dispose?: () => MaybePromise<void>;
   watch?: (callback: WatchCallback) => MaybePromise<Unwatch>;
 }
@@ -84,11 +89,16 @@ type StorageItemType<T, K> = K extends keyof StorageItemMap<T>
     ? StorageValue
     : T;
 
-type StorageSetOptions<DriverT extends Driver> = DriverT extends Driver<any, any, infer SetItemOptionsT>
-  ? SetItemOptionsT : never
+type StorageMethodOptions<DriverT extends Driver> = DriverT extends Driver<any, any, infer MethodOptionsT>
+  ? MethodOptionsT : never;
+
 
-type StorageGetOptions<DriverT extends Driver> = DriverT extends Driver<any, any, any, infer GetItemOptionsT>
-  ? GetItemOptionsT : never
+// if options type is not set it is unknown and we default back to TransactionOptions
+type SetOptionsType<DriverT extends Driver> = unknown extends StorageMethodOptions<DriverT>["setOptions"] ? TransactionOptions : StorageMethodOptions<DriverT>["setOptions"];
+type GetOptionsType<DriverT extends Driver> = unknown extends StorageMethodOptions<DriverT>["getOptions"] ? TransactionOptions : StorageMethodOptions<DriverT>["getOptions"];
+type RemoveOptionsType<DriverT extends Driver> = unknown extends StorageMethodOptions<DriverT>["removeOptions"] ? TransactionOptions : StorageMethodOptions<DriverT>["removeOptions"];
+type GetKeysOptionsType<DriverT extends Driver> = unknown extends StorageMethodOptions<DriverT>["getKeysOptions"] ? TransactionOptions : StorageMethodOptions<DriverT>["getKeysOptions"];
+type HasOptionsType<DriverT extends Driver> = unknown extends StorageMethodOptions<DriverT>["hasOptions"] ? TransactionOptions : StorageMethodOptions<DriverT>["hasOptions"];
 
 export interface Storage<T extends StorageValue = StorageValue, DriverT extends Driver = Driver> {
   // Item
@@ -97,31 +107,31 @@ export interface Storage<T extends StorageValue = StorageValue, DriverT extends
     K extends keyof StorageItemMap<U>,
   >(
     key: K,
-    opts?: TransactionOptions
+    opts?: HasOptionsType<DriverT>
   ): Promise<boolean>;
-  hasItem(key: string, opts?: TransactionOptions): Promise<boolean>;
+  hasItem(key: string, opts?: HasOptionsType<DriverT>): Promise<boolean>;
 
   getItem<
     U extends Extract<T, StorageDefinition>,
     K extends string & keyof StorageItemMap<U>,
   >(
     key: K,
-    ops?: StorageGetOptions<DriverT>
+    opts?: GetOptionsType<DriverT>
   ): Promise<StorageItemType<T, K> | null>;
   getItem<R = StorageItemType<T, string>>(
     key: string,
-    opts?: StorageGetOptions<DriverT>
+    opts?: GetOptionsType<DriverT>
   ): Promise<R | null>;
 
   /** @experimental */
   getItems: <U extends T>(
-    items: (string | { key: string; options?: StorageGetOptions<DriverT> })[],
-    commonOptions?: StorageGetOptions<DriverT>
+    items: (string | { key: string; options?: GetOptionsType<DriverT> })[],
+    commonOptions?: GetOptionsType<DriverT>
   ) => Promise<{ key: string; value: U }[]>;
   /** @experimental See https://github.com/unjs/unstorage/issues/142 */
   getItemRaw: <T = any>(
     key: string,
-    opts?: StorageGetOptions<DriverT>
+    opts?: GetOptionsType<DriverT>
   ) => Promise<MaybeDefined<T> | null>;
 
   setItem<
@@ -130,24 +140,24 @@ export interface Storage<T extends StorageValue = StorageValue, DriverT extends
   >(
     key: K,
     value: StorageItemType<T, K>,
-    opts?: StorageSetOptions<DriverT>
+    opts?: SetOptionsType<DriverT>
   ): Promise<void>;
   setItem<U extends T>(
     key: string,
     value: U,
-    opts?: StorageSetOptions<DriverT>
+    opts?: SetOptionsType<DriverT>
   ): Promise<void>;
 
   /** @experimental */
   setItems: <U extends T>(
-    items: { key: string; value: U; options?: StorageSetOptions<DriverT> }[],
-    commonOptions?: StorageSetOptions<DriverT>
+    items: { key: string; value: U; options?: SetOptionsType<DriverT> }[],
+    commonOptions?: SetOptionsType<DriverT>
   ) => Promise<void>;
   /** @experimental See https://github.com/unjs/unstorage/issues/142 */
   setItemRaw: <T = any>(
     key: string,
     value: MaybeDefined<T>,
-    opts?: StorageSetOptions<DriverT>
+    opts?: SetOptionsType<DriverT>
   ) => Promise<void>;
 
   removeItem<
@@ -156,13 +166,13 @@ export interface Storage<T extends StorageValue = StorageValue, DriverT extends
   >(
     key: K,
     opts?:
-      | (TransactionOptions & { removeMeta?: boolean })
+      | RemoveOptionsType<DriverT> & { removeMeta?: boolean }
       | boolean /* legacy: removeMeta */
   ): Promise<void>;
   removeItem(
     key: string,
     opts?:
-      | (TransactionOptions & { removeMeta?: boolean })
+      | RemoveOptionsType<DriverT> & { removeMeta?: boolean } 
       | boolean /* legacy: removeMeta */
   ): Promise<void>;
 
@@ -170,19 +180,19 @@ export interface Storage<T extends StorageValue = StorageValue, DriverT extends
   getMeta: (
     key: string,
     opts?:
-      | (TransactionOptions & { nativeOnly?: boolean })
+      | (GetOptionsType<DriverT> & { nativeOnly?: boolean })
       | boolean /* legacy: nativeOnly */
   ) => MaybePromise<StorageMeta>;
   setMeta: (
     key: string,
     value: StorageMeta,
-    opts?: TransactionOptions
+    opts?: SetOptionsType<DriverT>
   ) => Promise<void>;
-  removeMeta: (key: string, opts?: TransactionOptions) => Promise<void>;
+  removeMeta: (key: string, opts?: RemoveOptionsType<DriverT>) => Promise<void>;
   // Keys
-  getKeys: (base?: string, opts?: GetKeysOptions) => Promise<string[]>;
+  getKeys: (base?: string, opts?: GetKeysOptionsType<DriverT>) => Promise<string[]>;
   // Utils
-  clear: (base?: string, opts?: TransactionOptions) => Promise<void>;
+  clear: (base?: string, opts?: RemoveOptionsType<DriverT>) => Promise<void>;
   dispose: () => Promise<void>;
   watch: (callback: WatchCallback) => Promise<Unwatch>;
   unwatch: () => Promise<void>;
@@ -196,9 +206,9 @@ export interface Storage<T extends StorageValue = StorageValue, DriverT extends
   ) => { base: string; driver: Driver }[];
   // Aliases
   keys: Storage["getKeys"];
-  get: Storage<T>["getItem"];
-  set: Storage<T>["setItem"];
-  has: Storage<T>["hasItem"];
-  del: Storage<T>["removeItem"];
-  remove: Storage<T>["removeItem"];
+  get: Storage<T, DriverT>["getItem"];
+  set: Storage<T, DriverT>["setItem"];
+  has: Storage<T, DriverT>["hasItem"];
+  del: Storage<T, DriverT>["removeItem"];
+  remove: Storage<T, DriverT>["removeItem"];
 }

From de3de62facc461f97090622d0b8161b4986b7662 Mon Sep 17 00:00:00 2001
From: schplitt <schplitt.contact@gmail.com>
Date: Fri, 22 Aug 2025 19:56:50 +0200
Subject: [PATCH 03/10] fix: linting

---
 src/drivers/utils/index.ts | 10 +++--
 src/storage.ts             |  7 ++--
 src/types.ts               | 82 ++++++++++++++++++++++++++++----------
 3 files changed, 70 insertions(+), 29 deletions(-)

diff --git a/src/drivers/utils/index.ts b/src/drivers/utils/index.ts
index 2dded895b..6acbf9237 100644
--- a/src/drivers/utils/index.ts
+++ b/src/drivers/utils/index.ts
@@ -1,14 +1,16 @@
 import type { Driver, TransactionOpts } from "../..";
 
-type DriverFactory<OptionsT, InstanceT, TransactionOptsT extends TransactionOpts> = (
-  opts: OptionsT
-) => Driver<OptionsT, InstanceT, TransactionOptsT>;
+type DriverFactory<
+  OptionsT,
+  InstanceT,
+  TransactionOptsT extends TransactionOpts,
+> = (opts: OptionsT) => Driver<OptionsT, InstanceT, TransactionOptsT>;
 interface ErrorOptions {}
 
 export function defineDriver<
   OptionsT = any,
   InstanceT = never,
-  TransactionOptsT extends TransactionOpts = TransactionOpts
+  TransactionOptsT extends TransactionOpts = TransactionOpts,
 >(
   factory: DriverFactory<OptionsT, InstanceT, TransactionOptsT>
 ): DriverFactory<OptionsT, InstanceT, TransactionOptsT> {
diff --git a/src/storage.ts b/src/storage.ts
index 9ea66820f..525dee4ff 100644
--- a/src/storage.ts
+++ b/src/storage.ts
@@ -30,9 +30,10 @@ export interface CreateStorageOptions<DriverT extends Driver = Driver> {
   driver?: DriverT;
 }
 
-export function createStorage<T extends StorageValue, DriverT extends Driver = Driver>(
-  options: CreateStorageOptions<DriverT> = {}
-): Storage<T, DriverT> {
+export function createStorage<
+  T extends StorageValue,
+  DriverT extends Driver = Driver,
+>(options: CreateStorageOptions<DriverT> = {}): Storage<T, DriverT> {
   const context: StorageCTX = {
     mounts: { "": options.driver || memory() },
     mountpoints: [""],
diff --git a/src/types.ts b/src/types.ts
index a536d65d5..42eb691c1 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -17,39 +17,49 @@ export interface StorageMeta {
 
 export type TransactionOptions = Record<string, any>;
 
-
-
 export interface DriverFlags {
   maxDepth?: boolean;
   ttl?: boolean;
 }
 
-export type TransactionOpts<GetOptionsT = TransactionOptions, SetOptionsT = TransactionOptions, HasOptionsT = TransactionOptions, RemoveOptionsT = TransactionOptions, GetKeysOptionsT = TransactionOptions> = {
+export type TransactionOpts<
+  GetOptionsT = TransactionOptions,
+  SetOptionsT = TransactionOptions,
+  HasOptionsT = TransactionOptions,
+  RemoveOptionsT = TransactionOptions,
+  GetKeysOptionsT = TransactionOptions,
+> = {
   getOptions?: GetOptionsT;
   setOptions?: SetOptionsT;
   hasOptions?: HasOptionsT;
   removeOptions?: RemoveOptionsT;
   getKeysOptions?: GetKeysOptionsT;
-}
+};
 
 export interface Driver<
   OptionsT = any,
   InstanceT = any,
-  optionsT extends TransactionOpts = TransactionOpts
+  optionsT extends TransactionOpts = TransactionOpts,
 > {
   name?: string;
   flags?: DriverFlags;
   options?: OptionsT;
   getInstance?: () => InstanceT;
   hasItem: (key: string, opts: optionsT["hasOptions"]) => MaybePromise<boolean>;
-  getItem: (key: string, opts?: optionsT["getOptions"]) => MaybePromise<StorageValue>;
+  getItem: (
+    key: string,
+    opts?: optionsT["getOptions"]
+  ) => MaybePromise<StorageValue>;
   /** @experimental */
   getItems?: (
     items: { key: string; options?: optionsT["getOptions"] }[],
     commonOptions?: optionsT["getOptions"]
   ) => MaybePromise<{ key: string; value: StorageValue }[]>;
   /** @experimental */
-  getItemRaw?: (key: string, opts: optionsT["getOptions"]) => MaybePromise<unknown>;
+  getItemRaw?: (
+    key: string,
+    opts: optionsT["getOptions"]
+  ) => MaybePromise<unknown>;
   setItem?: (
     key: string,
     value: string,
@@ -66,12 +76,18 @@ export interface Driver<
     value: any,
     opts: optionsT["setOptions"]
   ) => MaybePromise<void>;
-  removeItem?: (key: string, opts: optionsT["removeOptions"]) => MaybePromise<void>;
+  removeItem?: (
+    key: string,
+    opts: optionsT["removeOptions"]
+  ) => MaybePromise<void>;
   getMeta?: (
     key: string,
     opts: optionsT["getOptions"]
   ) => MaybePromise<StorageMeta | null>;
-  getKeys: (base: string, opts: optionsT["getKeysOptions"]) => MaybePromise<string[]>;
+  getKeys: (
+    base: string,
+    opts: optionsT["getKeysOptions"]
+  ) => MaybePromise<string[]>;
   clear?: (base: string, opts: optionsT["removeOptions"]) => MaybePromise<void>;
   dispose?: () => MaybePromise<void>;
   watch?: (callback: WatchCallback) => MaybePromise<Unwatch>;
@@ -89,18 +105,37 @@ type StorageItemType<T, K> = K extends keyof StorageItemMap<T>
     ? StorageValue
     : T;
 
-type StorageMethodOptions<DriverT extends Driver> = DriverT extends Driver<any, any, infer MethodOptionsT>
-  ? MethodOptionsT : never;
-
+type StorageMethodOptions<DriverT extends Driver> =
+  DriverT extends Driver<any, any, infer MethodOptionsT>
+    ? MethodOptionsT
+    : never;
 
 // if options type is not set it is unknown and we default back to TransactionOptions
-type SetOptionsType<DriverT extends Driver> = unknown extends StorageMethodOptions<DriverT>["setOptions"] ? TransactionOptions : StorageMethodOptions<DriverT>["setOptions"];
-type GetOptionsType<DriverT extends Driver> = unknown extends StorageMethodOptions<DriverT>["getOptions"] ? TransactionOptions : StorageMethodOptions<DriverT>["getOptions"];
-type RemoveOptionsType<DriverT extends Driver> = unknown extends StorageMethodOptions<DriverT>["removeOptions"] ? TransactionOptions : StorageMethodOptions<DriverT>["removeOptions"];
-type GetKeysOptionsType<DriverT extends Driver> = unknown extends StorageMethodOptions<DriverT>["getKeysOptions"] ? TransactionOptions : StorageMethodOptions<DriverT>["getKeysOptions"];
-type HasOptionsType<DriverT extends Driver> = unknown extends StorageMethodOptions<DriverT>["hasOptions"] ? TransactionOptions : StorageMethodOptions<DriverT>["hasOptions"];
-
-export interface Storage<T extends StorageValue = StorageValue, DriverT extends Driver = Driver> {
+type SetOptionsType<DriverT extends Driver> =
+  unknown extends StorageMethodOptions<DriverT>["setOptions"]
+    ? TransactionOptions
+    : StorageMethodOptions<DriverT>["setOptions"];
+type GetOptionsType<DriverT extends Driver> =
+  unknown extends StorageMethodOptions<DriverT>["getOptions"]
+    ? TransactionOptions
+    : StorageMethodOptions<DriverT>["getOptions"];
+type RemoveOptionsType<DriverT extends Driver> =
+  unknown extends StorageMethodOptions<DriverT>["removeOptions"]
+    ? TransactionOptions
+    : StorageMethodOptions<DriverT>["removeOptions"];
+type GetKeysOptionsType<DriverT extends Driver> =
+  unknown extends StorageMethodOptions<DriverT>["getKeysOptions"]
+    ? TransactionOptions
+    : StorageMethodOptions<DriverT>["getKeysOptions"];
+type HasOptionsType<DriverT extends Driver> =
+  unknown extends StorageMethodOptions<DriverT>["hasOptions"]
+    ? TransactionOptions
+    : StorageMethodOptions<DriverT>["hasOptions"];
+
+export interface Storage<
+  T extends StorageValue = StorageValue,
+  DriverT extends Driver = Driver,
+> {
   // Item
   hasItem<
     U extends Extract<T, StorageDefinition>,
@@ -166,13 +201,13 @@ export interface Storage<T extends StorageValue = StorageValue, DriverT extends
   >(
     key: K,
     opts?:
-      | RemoveOptionsType<DriverT> & { removeMeta?: boolean }
+      | (RemoveOptionsType<DriverT> & { removeMeta?: boolean })
       | boolean /* legacy: removeMeta */
   ): Promise<void>;
   removeItem(
     key: string,
     opts?:
-      | RemoveOptionsType<DriverT> & { removeMeta?: boolean } 
+      | (RemoveOptionsType<DriverT> & { removeMeta?: boolean })
       | boolean /* legacy: removeMeta */
   ): Promise<void>;
 
@@ -190,7 +225,10 @@ export interface Storage<T extends StorageValue = StorageValue, DriverT extends
   ) => Promise<void>;
   removeMeta: (key: string, opts?: RemoveOptionsType<DriverT>) => Promise<void>;
   // Keys
-  getKeys: (base?: string, opts?: GetKeysOptionsType<DriverT>) => Promise<string[]>;
+  getKeys: (
+    base?: string,
+    opts?: GetKeysOptionsType<DriverT>
+  ) => Promise<string[]>;
   // Utils
   clear: (base?: string, opts?: RemoveOptionsType<DriverT>) => Promise<void>;
   dispose: () => Promise<void>;

From 27bac63709ae1cdf76623b16496f8ec77b4f299e Mon Sep 17 00:00:00 2001
From: schplitt <schplitt.contact@gmail.com>
Date: Fri, 22 Aug 2025 20:06:43 +0200
Subject: [PATCH 04/10] refactor(netlify-blobs): use new typed options driver
 to solve type issues

---
 src/drivers/netlify-blobs.ts | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/drivers/netlify-blobs.ts b/src/drivers/netlify-blobs.ts
index a8eb59bdf..08423bd56 100644
--- a/src/drivers/netlify-blobs.ts
+++ b/src/drivers/netlify-blobs.ts
@@ -1,5 +1,4 @@
 import { createError, createRequiredError, defineDriver } from "./utils";
-import type { GetKeysOptions } from "..";
 import { getStore, getDeployStore } from "@netlify/blobs";
 import type {
   Store,
@@ -46,7 +45,15 @@ export interface NetlifyNamedStoreOptions
   deployScoped?: false;
 }
 
-export default defineDriver((options: NetlifyStoreOptions) => {
+export interface NetlifyGetKeysOptions extends Omit<ListOptions, "prefix" | "paginate"> {
+  maxDepth?: number
+}
+
+export default defineDriver<NetlifyStoreOptions, Store, {
+  setOptions: SetOptions;
+  getOptions: GetOptions
+  getKeysOptions: NetlifyGetKeysOptions
+}>((options: NetlifyStoreOptions) => {
   const { deployScoped, name, ...opts } = options;
   let store: Store;
 
@@ -109,7 +116,7 @@ export default defineDriver((options: NetlifyStoreOptions) => {
     },
     async getKeys(
       base?: string,
-      tops?: GetKeysOptions & Omit<ListOptions, "prefix" | "paginate">
+      tops?: NetlifyGetKeysOptions
     ) {
       return (await getClient().list({ ...tops, prefix: base })).blobs.map(
         (item) => item.key

From 63ac0a70af411bb29c7df7b1df038897efef4e4e Mon Sep 17 00:00:00 2001
From: schplitt <schplitt.contact@gmail.com>
Date: Fri, 22 Aug 2025 20:07:14 +0200
Subject: [PATCH 05/10] fix(tests): allow any driver in testDriver

---
 test/drivers/utils.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/drivers/utils.ts b/test/drivers/utils.ts
index 9edd7fbc7..3977aebc2 100644
--- a/test/drivers/utils.ts
+++ b/test/drivers/utils.ts
@@ -11,8 +11,8 @@ export interface TestContext {
   driver: Driver;
 }
 
-export interface TestOptions {
-  driver: Driver | (() => Driver);
+export interface TestOptions{
+  driver: Driver<any, any, any> | (() => Driver<any, any, any>);
   noKeysSupport?: boolean;
   additionalTests?: (ctx: TestContext) => void;
 }

From 98ceb2f17e48d2e8001cf562cf58e88be73200ee Mon Sep 17 00:00:00 2001
From: schplitt <schplitt.contact@gmail.com>
Date: Fri, 22 Aug 2025 20:26:17 +0200
Subject: [PATCH 06/10] fix: make typed options partial by default when passed
 via `defineDriver`

---
 src/drivers/netlify-blobs.ts | 24 +++++++++++++-----------
 src/drivers/utils/index.ts   |  3 ++-
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/drivers/netlify-blobs.ts b/src/drivers/netlify-blobs.ts
index 08423bd56..b390b890d 100644
--- a/src/drivers/netlify-blobs.ts
+++ b/src/drivers/netlify-blobs.ts
@@ -45,15 +45,20 @@ export interface NetlifyNamedStoreOptions
   deployScoped?: false;
 }
 
-export interface NetlifyGetKeysOptions extends Omit<ListOptions, "prefix" | "paginate"> {
-  maxDepth?: number
+export interface NetlifyGetKeysOptions
+  extends Omit<ListOptions, "prefix" | "paginate"> {
+  maxDepth?: number;
 }
 
-export default defineDriver<NetlifyStoreOptions, Store, {
-  setOptions: SetOptions;
-  getOptions: GetOptions
-  getKeysOptions: NetlifyGetKeysOptions
-}>((options: NetlifyStoreOptions) => {
+export default defineDriver<
+  NetlifyStoreOptions,
+  Store,
+  {
+    setOptions: SetOptions;
+    getOptions: GetOptions;
+    getKeysOptions: NetlifyGetKeysOptions;
+  }
+>((options: NetlifyStoreOptions) => {
   const { deployScoped, name, ...opts } = options;
   let store: Store;
 
@@ -114,10 +119,7 @@ export default defineDriver<NetlifyStoreOptions, Store, {
     removeItem(key) {
       return getClient().delete(key);
     },
-    async getKeys(
-      base?: string,
-      tops?: NetlifyGetKeysOptions
-    ) {
+    async getKeys(base?: string, tops?: NetlifyGetKeysOptions) {
       return (await getClient().list({ ...tops, prefix: base })).blobs.map(
         (item) => item.key
       );
diff --git a/src/drivers/utils/index.ts b/src/drivers/utils/index.ts
index 6acbf9237..5f342cb88 100644
--- a/src/drivers/utils/index.ts
+++ b/src/drivers/utils/index.ts
@@ -4,7 +4,8 @@ type DriverFactory<
   OptionsT,
   InstanceT,
   TransactionOptsT extends TransactionOpts,
-> = (opts: OptionsT) => Driver<OptionsT, InstanceT, TransactionOptsT>;
+  // Partial here, to not required typed options to be optional in type argument
+> = (opts: OptionsT) => Driver<OptionsT, InstanceT, Partial<TransactionOptsT>>;
 interface ErrorOptions {}
 
 export function defineDriver<

From 9c5be21184d2359d72849733695a69b98278478e Mon Sep 17 00:00:00 2001
From: schplitt <schplitt.contact@gmail.com>
Date: Fri, 22 Aug 2025 20:26:26 +0200
Subject: [PATCH 07/10] fix: lint

---
 test/drivers/utils.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/drivers/utils.ts b/test/drivers/utils.ts
index 3977aebc2..92eaaffa7 100644
--- a/test/drivers/utils.ts
+++ b/test/drivers/utils.ts
@@ -11,7 +11,7 @@ export interface TestContext {
   driver: Driver;
 }
 
-export interface TestOptions{
+export interface TestOptions {
   driver: Driver<any, any, any> | (() => Driver<any, any, any>);
   noKeysSupport?: boolean;
   additionalTests?: (ctx: TestContext) => void;

From c12100c7430b2b633c500e0acea898a1c15dd196 Mon Sep 17 00:00:00 2001
From: schplitt <schplitt.contact@gmail.com>
Date: Fri, 22 Aug 2025 21:08:50 +0200
Subject: [PATCH 08/10] refactor: replace TransactionOpts with
 DriverMethodOptionsMap

---
 src/drivers/utils/index.ts | 12 +++++------
 src/types.ts               | 42 +++++++++++++++++++-------------------
 2 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/src/drivers/utils/index.ts b/src/drivers/utils/index.ts
index 5f342cb88..3bfca2971 100644
--- a/src/drivers/utils/index.ts
+++ b/src/drivers/utils/index.ts
@@ -1,20 +1,20 @@
-import type { Driver, TransactionOpts } from "../..";
+import type { Driver, DriverMethodOptionsMap } from "../..";
 
 type DriverFactory<
   OptionsT,
   InstanceT,
-  TransactionOptsT extends TransactionOpts,
+  DriverMethodOptionsMapT extends DriverMethodOptionsMap,
   // Partial here, to not required typed options to be optional in type argument
-> = (opts: OptionsT) => Driver<OptionsT, InstanceT, Partial<TransactionOptsT>>;
+> = (opts: OptionsT) => Driver<OptionsT, InstanceT, Partial<DriverMethodOptionsMapT>>;
 interface ErrorOptions {}
 
 export function defineDriver<
   OptionsT = any,
   InstanceT = never,
-  TransactionOptsT extends TransactionOpts = TransactionOpts,
+  DriverMethodOptionsMapT extends DriverMethodOptionsMap = DriverMethodOptionsMap,
 >(
-  factory: DriverFactory<OptionsT, InstanceT, TransactionOptsT>
-): DriverFactory<OptionsT, InstanceT, TransactionOptsT> {
+  factory: DriverFactory<OptionsT, InstanceT, DriverMethodOptionsMapT>
+): DriverFactory<OptionsT, InstanceT, DriverMethodOptionsMapT> {
   return factory;
 }
 
diff --git a/src/types.ts b/src/types.ts
index 42eb691c1..1e5a3dabb 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -22,73 +22,73 @@ export interface DriverFlags {
   ttl?: boolean;
 }
 
-export type TransactionOpts<
+export type DriverMethodOptionsMap<
   GetOptionsT = TransactionOptions,
   SetOptionsT = TransactionOptions,
   HasOptionsT = TransactionOptions,
   RemoveOptionsT = TransactionOptions,
   GetKeysOptionsT = TransactionOptions,
 > = {
-  getOptions?: GetOptionsT;
-  setOptions?: SetOptionsT;
-  hasOptions?: HasOptionsT;
-  removeOptions?: RemoveOptionsT;
-  getKeysOptions?: GetKeysOptionsT;
+  getOptions?: GetOptionsT ;
+  setOptions?: SetOptionsT ;
+  hasOptions?: HasOptionsT ;
+  removeOptions?: RemoveOptionsT ;
+  getKeysOptions?: GetKeysOptionsT ;
 };
 
 export interface Driver<
   OptionsT = any,
   InstanceT = any,
-  optionsT extends TransactionOpts = TransactionOpts,
+  DriverMethodOptionsMapT extends DriverMethodOptionsMap = DriverMethodOptionsMap,
 > {
   name?: string;
   flags?: DriverFlags;
   options?: OptionsT;
   getInstance?: () => InstanceT;
-  hasItem: (key: string, opts: optionsT["hasOptions"]) => MaybePromise<boolean>;
+  hasItem: (key: string, opts: DriverMethodOptionsMapT["hasOptions"]) => MaybePromise<boolean>;
   getItem: (
     key: string,
-    opts?: optionsT["getOptions"]
+    opts?: DriverMethodOptionsMapT["getOptions"]
   ) => MaybePromise<StorageValue>;
   /** @experimental */
   getItems?: (
-    items: { key: string; options?: optionsT["getOptions"] }[],
-    commonOptions?: optionsT["getOptions"]
+    items: { key: string; options?: DriverMethodOptionsMapT["getOptions"] }[],
+    commonOptions?: DriverMethodOptionsMapT["getOptions"]
   ) => MaybePromise<{ key: string; value: StorageValue }[]>;
   /** @experimental */
   getItemRaw?: (
     key: string,
-    opts: optionsT["getOptions"]
+    opts: DriverMethodOptionsMapT["getOptions"]
   ) => MaybePromise<unknown>;
   setItem?: (
     key: string,
     value: string,
-    opts: optionsT["setOptions"]
+    opts: DriverMethodOptionsMapT["setOptions"]
   ) => MaybePromise<void>;
   /** @experimental */
   setItems?: (
-    items: { key: string; value: string; options?: optionsT["setOptions"] }[],
-    commonOptions?: optionsT["setOptions"]
+    items: { key: string; value: string; options?: DriverMethodOptionsMapT["setOptions"] }[],
+    commonOptions?: DriverMethodOptionsMapT["setOptions"]
   ) => MaybePromise<void>;
   /** @experimental */
   setItemRaw?: (
     key: string,
     value: any,
-    opts: optionsT["setOptions"]
+    opts: DriverMethodOptionsMapT["setOptions"]
   ) => MaybePromise<void>;
   removeItem?: (
     key: string,
-    opts: optionsT["removeOptions"]
+    opts: DriverMethodOptionsMapT["removeOptions"]
   ) => MaybePromise<void>;
   getMeta?: (
     key: string,
-    opts: optionsT["getOptions"]
+    opts: DriverMethodOptionsMapT["getOptions"]
   ) => MaybePromise<StorageMeta | null>;
   getKeys: (
     base: string,
-    opts: optionsT["getKeysOptions"]
+    opts: DriverMethodOptionsMapT["getKeysOptions"]
   ) => MaybePromise<string[]>;
-  clear?: (base: string, opts: optionsT["removeOptions"]) => MaybePromise<void>;
+  clear?: (base: string, opts: DriverMethodOptionsMapT["removeOptions"]) => MaybePromise<void>;
   dispose?: () => MaybePromise<void>;
   watch?: (callback: WatchCallback) => MaybePromise<Unwatch>;
 }
@@ -114,7 +114,7 @@ type StorageMethodOptions<DriverT extends Driver> =
 type SetOptionsType<DriverT extends Driver> =
   unknown extends StorageMethodOptions<DriverT>["setOptions"]
     ? TransactionOptions
-    : StorageMethodOptions<DriverT>["setOptions"];
+    : StorageMethodOptions<DriverT>["setOptions"] | undefined;
 type GetOptionsType<DriverT extends Driver> =
   unknown extends StorageMethodOptions<DriverT>["getOptions"]
     ? TransactionOptions

From 939cc624c174dc26ed040e96e2d7eaed6d0c87ee Mon Sep 17 00:00:00 2001
From: "autofix-ci[bot]" <114827586+autofix-ci[bot]@users.noreply.github.com>
Date: Fri, 22 Aug 2025 19:38:07 +0000
Subject: [PATCH 09/10] chore: apply automated updates

---
 src/drivers/utils/index.ts |  7 +++++--
 src/types.ts               | 29 ++++++++++++++++++++---------
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/src/drivers/utils/index.ts b/src/drivers/utils/index.ts
index 3bfca2971..96d02508f 100644
--- a/src/drivers/utils/index.ts
+++ b/src/drivers/utils/index.ts
@@ -5,13 +5,16 @@ type DriverFactory<
   InstanceT,
   DriverMethodOptionsMapT extends DriverMethodOptionsMap,
   // Partial here, to not required typed options to be optional in type argument
-> = (opts: OptionsT) => Driver<OptionsT, InstanceT, Partial<DriverMethodOptionsMapT>>;
+> = (
+  opts: OptionsT
+) => Driver<OptionsT, InstanceT, Partial<DriverMethodOptionsMapT>>;
 interface ErrorOptions {}
 
 export function defineDriver<
   OptionsT = any,
   InstanceT = never,
-  DriverMethodOptionsMapT extends DriverMethodOptionsMap = DriverMethodOptionsMap,
+  DriverMethodOptionsMapT extends
+    DriverMethodOptionsMap = DriverMethodOptionsMap,
 >(
   factory: DriverFactory<OptionsT, InstanceT, DriverMethodOptionsMapT>
 ): DriverFactory<OptionsT, InstanceT, DriverMethodOptionsMapT> {
diff --git a/src/types.ts b/src/types.ts
index 1e5a3dabb..23d32d513 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -29,23 +29,27 @@ export type DriverMethodOptionsMap<
   RemoveOptionsT = TransactionOptions,
   GetKeysOptionsT = TransactionOptions,
 > = {
-  getOptions?: GetOptionsT ;
-  setOptions?: SetOptionsT ;
-  hasOptions?: HasOptionsT ;
-  removeOptions?: RemoveOptionsT ;
-  getKeysOptions?: GetKeysOptionsT ;
+  getOptions?: GetOptionsT;
+  setOptions?: SetOptionsT;
+  hasOptions?: HasOptionsT;
+  removeOptions?: RemoveOptionsT;
+  getKeysOptions?: GetKeysOptionsT;
 };
 
 export interface Driver<
   OptionsT = any,
   InstanceT = any,
-  DriverMethodOptionsMapT extends DriverMethodOptionsMap = DriverMethodOptionsMap,
+  DriverMethodOptionsMapT extends
+    DriverMethodOptionsMap = DriverMethodOptionsMap,
 > {
   name?: string;
   flags?: DriverFlags;
   options?: OptionsT;
   getInstance?: () => InstanceT;
-  hasItem: (key: string, opts: DriverMethodOptionsMapT["hasOptions"]) => MaybePromise<boolean>;
+  hasItem: (
+    key: string,
+    opts: DriverMethodOptionsMapT["hasOptions"]
+  ) => MaybePromise<boolean>;
   getItem: (
     key: string,
     opts?: DriverMethodOptionsMapT["getOptions"]
@@ -67,7 +71,11 @@ export interface Driver<
   ) => MaybePromise<void>;
   /** @experimental */
   setItems?: (
-    items: { key: string; value: string; options?: DriverMethodOptionsMapT["setOptions"] }[],
+    items: {
+      key: string;
+      value: string;
+      options?: DriverMethodOptionsMapT["setOptions"];
+    }[],
     commonOptions?: DriverMethodOptionsMapT["setOptions"]
   ) => MaybePromise<void>;
   /** @experimental */
@@ -88,7 +96,10 @@ export interface Driver<
     base: string,
     opts: DriverMethodOptionsMapT["getKeysOptions"]
   ) => MaybePromise<string[]>;
-  clear?: (base: string, opts: DriverMethodOptionsMapT["removeOptions"]) => MaybePromise<void>;
+  clear?: (
+    base: string,
+    opts: DriverMethodOptionsMapT["removeOptions"]
+  ) => MaybePromise<void>;
   dispose?: () => MaybePromise<void>;
   watch?: (callback: WatchCallback) => MaybePromise<Unwatch>;
 }

From 3e8310501c81b8b81fa077d217e78cab5ce24348 Mon Sep 17 00:00:00 2001
From: schplitt <schplitt.contact@gmail.com>
Date: Fri, 22 Aug 2025 21:55:19 +0200
Subject: [PATCH 10/10] fix(deno-kv): make tOptions optional in setItem and
 setItemRaw methods

---
 src/drivers/deno-kv.ts | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/drivers/deno-kv.ts b/src/drivers/deno-kv.ts
index 0b1808077..497d39d8e 100644
--- a/src/drivers/deno-kv.ts
+++ b/src/drivers/deno-kv.ts
@@ -12,6 +12,7 @@ export interface DenoKvOptions {
    */
   ttl?: number;
 }
+
 interface DenoKVSetOptions {
   /**
    * TTL in seconds.
@@ -75,12 +76,12 @@ export default defineDriver<DenoKvOptions, Promise<Deno.Kv | Kv>>(
         const value = await kv.get(r(key));
         return value.value;
       },
-      async setItem(key, value, tOptions: DenoKVSetOptions) {
+      async setItem(key, value, tOptions?: DenoKVSetOptions) {
         const ttl = normalizeTTL(tOptions?.ttl ?? opts?.ttl);
         const kv = await getKv();
         await kv.set(r(key), value, { expireIn: ttl });
       },
-      async setItemRaw(key, value, tOptions: DenoKVSetOptions) {
+      async setItemRaw(key, value, tOptions?: DenoKVSetOptions) {
         const ttl = normalizeTTL(tOptions?.ttl ?? opts?.ttl);
         const kv = await getKv();
         await kv.set(r(key), value, { expireIn: ttl });