keyv 6.0.0-beta.3 → 6.0.0-beta.4

package/dist/index.d.mts

@@ -21,6 +21,20 @@ type KeyvStorageCapability = {
   compatible: boolean;
   store: "mapLike" | "keyvStorage" | "asyncMap" | "none";
   methods: KeyvStorageMethods;
+  /**
+   * Whether the adapter implements the v6 storage contract — it accepts an absolute
+   * `expires` timestamp (ms since epoch) on `set`/`setMany`. Adapters that omit this
+   * (legacy relative-`ttl` adapters) are wrapped by `KeyvBridgeAdapter`, which converts
+   * the absolute `expires` back to a relative ttl before delegating.
+   *
+   * Declaring `expires: true` is a two-way contract: the adapter is then used directly and
+   * must ENFORCE expiry on read. Keyv core does not filter expired entries by default
+   * (`checkExpired` is off), so the adapter is the expiry authority — `get`/`getMany`/`has`
+   * must return nothing for a key past its deadline, via a native mechanism (TTL index, key
+   * expiry, lease) and/or a client-side check. Validate with `@keyv/test-suite`'s
+   * `storageTtlTests`.
+   */
+  expires?: boolean;
 };
 declare const keyvCompressionMethodNames: readonly ["compress", "decompress"];
 type KeyvCompressionMethods = Record<(typeof keyvCompressionMethodNames)[number], KeyvStorageMethod>;
@@ -83,6 +97,21 @@ declare function detectKeyv(obj: unknown): KeyvCapability;
  * ```
  */
 declare function detectKeyvStorage(obj: unknown): KeyvStorageCapability;
+/**
+ * Build the capability descriptor for a v6 storage adapter: the structurally detected
+ * methods plus `expires: true`, declaring that the adapter accepts an absolute `expires`
+ * timestamp on `set`/`setMany`. First-party adapters expose this from their `capabilities`
+ * getter so Keyv uses them directly instead of bridging.
+ * @param adapter - The storage adapter to describe (typically `this`).
+ * @returns A {@link KeyvStorageCapability} with `expires` set to `true`.
+ * @example
+ * ```typescript
+ * public get capabilities(): KeyvStorageCapability {
+ *   return keyvStorageCapability(this);
+ * }
+ * ```
+ */
+declare function keyvStorageCapability(adapter: object): KeyvStorageCapability;
 /**
  * Detect whether an object implements the Keyv compression adapter interface
  * @param obj - The object to check
@@ -493,7 +522,8 @@ declare enum KeyvHooks {
   AFTER_DISCONNECT = "after:disconnect"
 }
 /**
- * Represents a key-value entry with an optional TTL, used for batch operations like `setMany`.
+ * Represents a key-value entry with an optional TTL, used for the public
+ * batch API `Keyv.setMany`.
  */
 type KeyvEntry<Value = any> = {
   /**
@@ -509,6 +539,17 @@ type KeyvEntry<Value = any> = {
    */
   ttl?: number;
 };
+/**
+ * Represents a key-value entry at the storage-adapter boundary, carrying an
+ * absolute `expires` timestamp instead of a relative `ttl`. Keyv core computes
+ * `expires` once and passes these to a storage adapter's `setMany`, so adapters
+ * never derive expiry themselves.
+ */
+type KeyvStorageEntry<Value = any> = {
+  /** Key to set. */key: string; /** Value to set (already encoded by Keyv core). */
+  value: Value; /** Absolute expiry as Unix ms since epoch, or `undefined` for no expiry. */
+  expires?: number;
+};
 /**
  * Configuration options for the Keyv constructor.
  */
@@ -602,11 +643,26 @@ type KeyvStorageGetResult<Value> = KeyvValue<Value> | string | undefined;
  * Adapters handle the actual persistence of key-value pairs.
  */
 type KeyvStorageAdapter = {
-  /** Optional namespace for key isolation. */namespace?: string | undefined; /** Detected capabilities of the underlying store. */
+  /** Optional namespace for key isolation. */namespace?: string | undefined;
+  /**
+   * The adapter's capabilities. v6 adapters set `capabilities.expires = true` (e.g. via
+   * `keyvStorageCapability(this)`) to declare they accept an absolute `expires` timestamp
+   * on `set`/`setMany`. Full storage adapters that omit it are treated as legacy relative-`ttl`
+   * adapters and wrapped by `KeyvBridgeAdapter`, which converts `expires` back to a ttl.
+   *
+   * Declaring `expires: true` also obliges the adapter to enforce expiry on read: Keyv core
+   * does not filter expired entries by default, so `get`/`getMany`/`has` must not return a key
+   * past its deadline. See {@link KeyvStorageCapability.expires}.
+   */
   capabilities?: KeyvStorageCapability; /** Retrieves a value by key. */
-  get<Value>(key: string): Promise<KeyvStorageGetResult<Value>>; /** Stores a value with a key and optional TTL in milliseconds. */
-  set(key: string, value: unknown, ttl?: number): Promise<boolean>; /** Stores multiple entries at once. */
-  setMany<Value>(values: KeyvEntry<Value>[]): Promise<boolean[] | undefined>; /** Deletes a key from the store. */
+  get<Value>(key: string): Promise<KeyvStorageGetResult<Value>>;
+  /**
+   * Stores a value with a key and optional absolute expiry.
+   * @param expires Absolute expiry as Unix ms since epoch; `undefined` means no expiry.
+   * A value `<= Date.now()` is already expired and the adapter may delete/skip it.
+   */
+  set(key: string, value: unknown, expires?: number): Promise<boolean>; /** Stores multiple entries at once, each with an absolute `expires` timestamp. */
+  setMany<Value>(values: KeyvStorageEntry<Value>[]): Promise<boolean[] | undefined>; /** Deletes a key from the store. */
   delete(key: string): Promise<boolean>; /** Clears all entries from the store (respects namespace if set). */
   clear(): Promise<void>; /** Checks if a key exists in the store. */
   has(key: string): Promise<boolean>; /** Checks if multiple keys exist in the store. */
@@ -647,7 +703,8 @@ type KeyvBridgeAdapterOptions = {
  * will be delegated to the store if present, otherwise fallback implementations are used.
  */
 type KeyvBridgeStore = {
-  /** Store configuration/options (e.g. dialect, url) */opts?: any; /** Retrieves a value by key */
+  /** Store configuration/options (e.g. dialect, url) */opts?: any; /** Namespace the store scopes its keys under, when it manages its own namespacing. */
+  namespace?: string; /** Retrieves a value by key */
   get(key: string): Promise<any>; /** Sets a value with a key and optional TTL */
   set(key: string, value: any, ttl?: number): Promise<any>; /** Deletes a key from the store */
   delete(key: string): Promise<boolean>; /** Clears all entries from the store */
@@ -690,6 +747,12 @@ declare class KeyvBridgeAdapter extends Hookified implements KeyvStorageAdapter
   private _namespace?;
   private _keySeparator;
   private readonly _capabilities;
+  /**
+   * Whether the wrapped store manages its own namespace (exposes a `namespace` property).
+   * When true the bridge propagates its namespace to the store and does not prefix keys,
+   * so the store's native, namespace-scoped operations (notably `clear()`) are used directly.
+   */
+  private readonly _storeHandlesNamespace;
   /**
    * Creates a new KeyvBridgeAdapter instance.
    * @param store - The underlying promise-based store to bridge
@@ -705,7 +768,9 @@ declare class KeyvBridgeAdapter extends Hookified implements KeyvStorageAdapter
    */
   set store(store: KeyvBridgeStore);
   /**
-   * Gets the detected capabilities of the underlying store.
+   * Gets the capabilities of the underlying store, with `expires: true` to declare that
+   * the bridge accepts an absolute `expires` timestamp (which it converts to a ttl for the
+   * wrapped legacy store).
    */
   get capabilities(): KeyvStorageCapability;
   /**
@@ -721,7 +786,8 @@ declare class KeyvBridgeAdapter extends Hookified implements KeyvStorageAdapter
    */
   get namespace(): string | undefined;
   /**
-   * Sets the namespace.
+   * Sets the namespace. When the wrapped store manages its own namespace, the value is
+   * propagated to it so its native scoped operations stay in sync.
    */
   set namespace(namespace: string | undefined);
   /**
@@ -752,19 +818,25 @@ declare class KeyvBridgeAdapter extends Hookified implements KeyvStorageAdapter
    */
   getMany<T>(keys: string[]): Promise<Array<KeyvStorageGetResult<T | undefined>>>;
   /**
-   * Stores a value in the store with an optional TTL.
+   * Stores a value in the store with an optional absolute expiry.
+   * The wrapped store's `set(key, value, ttl?)` expects a relative duration, so the absolute
+   * `expires` is converted to a remaining ttl (`undefined` when already expired or absent).
+   * The value is passed through unchanged — the bridge does not wrap it in an envelope — so
+   * expiry is enforced by the wrapped legacy store's own ttl handling. (The read-side
+   * {@link isDataExpired} check only fires when a caller stores a raw `{ value, expires }`
+   * object directly; when Keyv core drives the bridge the value arrives already encoded.)
    * @param key - The key to store the value under
    * @param value - The value to store
-   * @param ttl - Optional time-to-live in milliseconds
+   * @param expires - Optional absolute expiry as Unix ms since epoch
    * @returns Always returns true indicating success
    */
-  set(key: string, value: any, ttl?: number): Promise<boolean>;
+  set(key: string, value: any, expires?: number): Promise<boolean>;
   /**
    * Stores multiple entries in the store at once.
    * Delegates to the store's native setMany if available, otherwise loops over set.
-   * @param entries - Array of entries containing key, value, and optional TTL
+   * @param entries - Array of entries containing key, value, and optional absolute `expires`
    */
-  setMany<Value>(entries: KeyvEntry<Value>[]): Promise<boolean[] | undefined>;
+  setMany<Value>(entries: KeyvStorageEntry<Value>[]): Promise<boolean[] | undefined>;
   /**
    * Checks if a key exists in the store and is not expired.
    * Delegates to the store's native has if available.
@@ -813,6 +885,17 @@ declare class KeyvBridgeAdapter extends Hookified implements KeyvStorageAdapter
 //#endregion
 //#region src/keyv.d.ts
 declare class Keyv<GenericValue = any> extends Hookified {
+  /**
+   * Keyv Constructor
+   * @param {KeyvStorageAdapter | KeyvOptions | Map<any, any> | any} store  to be provided or just the options
+   * @param {Omit<KeyvOptions, 'store'>} [options] if you provide the store you can then provide the Keyv Options
+   */
+  constructor(store?: KeyvStorageAdapter | KeyvOptions | KeyvMapAny, options?: Omit<KeyvOptions, "store">);
+  /**
+   * Keyv Constructor
+   * @param {KeyvOptions} options to be provided
+   */
+  constructor(options?: KeyvOptions);
   /**
    * Stats manager for tracking cache operation metrics (hits, misses, sets, deletes, errors).
    * @default this is disabled.
@@ -851,17 +934,6 @@ declare class Keyv<GenericValue = any> extends Hookified {
    * When true, Keyv checks expiry at its layer on get/getMany/has/hasMany.
    */
   private _checkExpired;
-  /**
-   * Keyv Constructor
-   * @param {KeyvStorageAdapter | KeyvOptions | Map<any, any> | any} store  to be provided or just the options
-   * @param {Omit<KeyvOptions, 'store'>} [options] if you provide the store you can then provide the Keyv Options
-   */
-  constructor(store?: KeyvStorageAdapter | KeyvOptions | KeyvMapAny, options?: Omit<KeyvOptions, "store">);
-  /**
-   * Keyv Constructor
-   * @param {KeyvOptions} options to be provided
-   */
-  constructor(options?: KeyvOptions);
   /**
    * Get the current storage adapter.
    * @returns {KeyvStorageAdapter} The current storage adapter.
@@ -952,11 +1024,6 @@ declare class Keyv<GenericValue = any> extends Hookified {
    * @returns {KeyvStats} The current stats.
    */
   get stats(): KeyvStats;
-  /**
-   * When true, Keyv checks expiry at its layer on get/getMany/has/hasMany.
-   * When false (default), trusts the storage adapter.
-   */
-  get checkExpired(): boolean;
   /**
    * Set the stats. When setting a new instance it will unsubscribe the old listeners
    * and subscribe the new instance.
@@ -964,11 +1031,21 @@ declare class Keyv<GenericValue = any> extends Hookified {
    */
   set stats(stats: KeyvStats);
   /**
-   * Resolves a store to a fully-compliant KeyvStorageAdapter using a 3-tier detection chain:
-   * 1. If the store already implements the full KeyvStorageAdapter interface, use it directly.
-   * 2. If the store is map-like (synchronous get/set/delete/has), wrap it in KeyvMemoryAdapter.
-   * 3. If the store has async get/set/delete/clear, wrap it in KeyvBridgeAdapter.
-   * 4. Otherwise, emit an error and fall back to a default in-memory KeyvMemoryAdapter.
+   * Get whether Keyv checks expiry at its own layer on get/getMany/has/hasMany.
+   * When false (default), it trusts the storage adapter to handle expiry.
+   * @returns {boolean} `true` if Keyv checks expiry at its layer.
+   */
+  get checkExpired(): boolean;
+  /**
+   * Resolves a store to a fully-compliant KeyvStorageAdapter:
+   * 1. If the store declares the v6 `capabilities.expires` contract, use it directly (this takes
+   *    precedence over structural detection, so a full adapter whose async methods aren't written
+   *    with the `async` keyword is not mis-bridged).
+   * 2. If the store implements the full async storage interface (but doesn't declare `expires`),
+   *    treat it as a legacy relative-`ttl` adapter and wrap it in KeyvBridgeAdapter.
+   * 3. If the store is map-like (synchronous get/set/delete/has), wrap it in KeyvMemoryAdapter.
+   * 4. If the store has async get/set/delete/clear, wrap it in KeyvBridgeAdapter.
+   * 5. Otherwise, emit an error and fall back to a default in-memory KeyvMemoryAdapter.
    *
    * NOTE: this is used for internal but provided public for custom adapter testing
    * @param {unknown} store The store to resolve.
@@ -987,14 +1064,29 @@ declare class Keyv<GenericValue = any> extends Hookified {
    */
   setTtl(ttl?: number): void;
   /**
-   * Get the Value of a Key
+   * Get the value of a key. If an array of keys is passed in it will return an array of values
+   * delegating to {@link getMany}.
    * @param {string | string[]} key passing in a single key or multiple as an array
+   * @returns {Promise<Value | undefined | Array<Value | undefined>>} the value of the key, or
+   * `undefined` if the key does not exist or is expired. When an array of keys is passed in it
+   * returns an array of values in the same order (with `undefined` for missing keys).
    */
   get<Value = GenericValue>(key: string): Promise<Value | undefined>;
   get<Value = GenericValue>(key: string[]): Promise<Array<Value | undefined>>;
   /**
-   * Get many values of keys
-   * @param {string[]} keys passing in a single key or multiple as an array
+   * Reads many keys from the store, preferring its native `getMany` and falling back to parallel
+   * single `get`s when an adapter does not implement it. A directly-used v6 adapter is not
+   * structurally required to provide `getMany` (the bridge and memory adapters always do), so
+   * this keeps `getMany`/`getManyRaw` working regardless of the resolved adapter.
+   * @param keys - the keys to read
+   * @returns the raw store results in the same order as `keys`
+   */
+  private storeGetMany;
+  /**
+   * Get many values for an array of keys.
+   * @param {string[]} keys the keys to get
+   * @returns {Promise<Array<Value | undefined>>} an array of values in the same order as the
+   * keys, with `undefined` for keys that do not exist or are expired.
    */
   getMany<Value = GenericValue>(keys: string[]): Promise<Array<Value | undefined>>;
   /**
@@ -1012,16 +1104,16 @@ declare class Keyv<GenericValue = any> extends Hookified {
   getManyRaw<Value = GenericValue>(keys: string[]): Promise<Array<KeyvStorageGetResult<Value>>>;
   /**
    * Set an item to the store
-   * @param {string | Array<KeyvEntry<Value>>} key the key to use. If you pass in an array of KeyvEntry it will set many items
+   * @param {string} key the key to use
    * @param {Value} value the value of the key
-   * @param {number} [ttl] time to live in milliseconds
-   * @returns {boolean} if it sets then it will return a true. On failure will return false.
+   * @param {number} [ttl] time to live in milliseconds. Overrides the instance-level `ttl`.
+   * @returns {Promise<boolean>} `true` if it was set successfully, `false` on failure.
    */
   set<Value = GenericValue>(key: string, value: Value, ttl?: number): Promise<boolean>;
   /**
    * Set many items to the store
    * @param {Array<KeyvEntry<Value>>} entries the entries to set
-   * @returns {boolean[]} will return an array of booleans if it sets then it will return a true. On failure will return false.
+   * @returns {Promise<boolean[]>} an array of booleans, one per entry: `true` if set successfully, `false` on failure.
    */
   setMany<Value = GenericValue>(entries: KeyvEntry<Value>[]): Promise<boolean[]>;
   /**
@@ -1031,7 +1123,7 @@ declare class Keyv<GenericValue = any> extends Hookified {
    * The store-level TTL is derived automatically from `value.expires`.
    * @param {string} key the key to set
    * @param {KeyvValue<Value>} value the raw value envelope to store
-   * @returns {boolean} if it sets then it will return a true. On failure will return false.
+   * @returns {Promise<boolean>} `true` if it was set successfully, `false` on failure.
    */
   setRaw<Value = GenericValue>(key: string, value: KeyvValue<Value>): Promise<boolean>;
   /**
@@ -1039,43 +1131,47 @@ declare class Keyv<GenericValue = any> extends Hookified {
    * Each entry's value should be a KeyvValue object with { value, expires? }. If you need TTL-based expiration,
    * set `expires` on each value directly. The store-level TTL is derived automatically from `value.expires`.
    * @param {KeyvEntry<KeyvValue<Value>>[]} entries the raw entries to set
-   * @returns {boolean[]} will return an array of booleans if it sets then it will return a true. On failure will return false.
+   * @returns {Promise<boolean[]>} an array of booleans, one per entry: `true` if set successfully, `false` on failure.
    */
   setManyRaw<Value = GenericValue>(entries: KeyvEntry<KeyvValue<Value>>[]): Promise<boolean[]>;
   /**
-   * Delete an Entry
+   * Delete an entry. If an array of keys is passed in it will delete many entries
+   * delegating to {@link deleteMany}.
    * @param {string} key the key to be deleted
-   * @returns {boolean} will return true if item is deleted. false if there is an error
+   * @returns {Promise<boolean>} `true` if the item was deleted, `false` if there was an error.
    */
   delete(key: string): Promise<boolean>;
   /**
-   * Delete multiple Entries
+   * Delete multiple entries
    * @param {string[]} keys the keys to be deleted
-   * @returns {boolean[]} will return array of booleans for each key
+   * @returns {Promise<boolean[]>} an array of booleans indicating success for each key.
    */
   delete(keys: string[]): Promise<boolean[]>;
   /**
    * Delete many items from the store
    * @param {string[]} keys the keys to be deleted
-   * @returns {boolean[]} array of booleans indicating success for each key
+   * @returns {Promise<boolean[]>} an array of booleans indicating success for each key.
    */
   deleteMany(keys: string[]): Promise<boolean[]>;
   /**
-   * Has a key.
-   * @param {string} key the key to check
-   * @returns {boolean} will return true if the key exists
+   * Check if a key exists. If an array of keys is passed in it will check many keys
+   * delegating to {@link hasMany}.
+   * @param {string | string[]} key the key (or keys) to check
+   * @returns {Promise<boolean | boolean[]>} `true` if the key exists, `false` if not. When an
+   * array of keys is passed in it returns an array of booleans in the same order.
    */
   has(key: string[]): Promise<boolean[]>;
   has(key: string): Promise<boolean>;
   /**
    * Check if many keys exist
    * @param {string[]} keys the keys to check
-   * @returns {boolean[]} will return an array of booleans if the keys exist
+   * @returns {Promise<boolean[]>} an array of booleans in the same order as the keys, `true` if the key exists.
    */
   hasMany(keys: string[]): Promise<boolean[]>;
   /**
-   * Clear the store
-   * @returns {void}
+   * Clear the store. If a namespace is set only entries in that namespace are removed.
+   * Emits a `clear` event.
+   * @returns {Promise<void>} resolves once the entries have been cleared.
    */
   clear(): Promise<void>;
   /**
@@ -1202,7 +1298,8 @@ declare class KeyvMemoryAdapter extends Hookified implements KeyvStorageAdapter
    */
   constructor(store: KeyvMapType, options?: KeyvMemoryAdapterOptions);
   /**
-   * Gets the detected capabilities of the underlying store.
+   * Gets the capabilities of the underlying store, with `expires: true` to declare that
+   * this adapter accepts an absolute `expires` timestamp (the v6 storage contract).
    */
   get capabilities(): KeyvStorageCapability;
   /**
@@ -1256,18 +1353,18 @@ declare class KeyvMemoryAdapter extends Hookified implements KeyvStorageAdapter
    */
   get<T>(key: string): Promise<KeyvStorageGetResult<T>>;
   /**
-   * Stores a value in the store with an optional TTL.
+   * Stores a value in the store with an optional absolute expiry.
    * @param key - The key to store the value under
    * @param value - The value to store
-   * @param ttl - Optional time-to-live in milliseconds
+   * @param expires - Optional absolute expiry as Unix ms since epoch
    * @returns Always returns true indicating success
    */
-  set(key: string, value: any, ttl?: number): Promise<boolean>;
+  set(key: string, value: any, expires?: number): Promise<boolean>;
   /**
    * Stores multiple entries in the store at once.
-   * @param entries - Array of entries containing key, value, and optional TTL
+   * @param entries - Array of entries containing key, value, and optional absolute `expires`
    */
-  setMany<Value>(entries: KeyvEntry<Value>[]): Promise<boolean[] | undefined>;
+  setMany<Value>(entries: KeyvStorageEntry<Value>[]): Promise<boolean[] | undefined>;
   /**
    * Deletes a value from the store by key.
    * @param key - The key to delete
@@ -1348,4 +1445,4 @@ declare class KeyvJsonSerializer implements KeyvSerializationAdapter {
 }
 declare const jsonSerializer: KeyvJsonSerializer;
 //#endregion
-export { type DeserializedData, Keyv, Keyv as default, KeyvBridgeAdapter, type KeyvBridgeAdapterOptions, type KeyvBridgeStore, type KeyvCapability, type KeyvCompression, type KeyvCompressionAdapter, type KeyvCompressionCapability, type KeyvCompressionMethods, type KeyvEncryptionAdapter, type KeyvEncryptionCapability, type KeyvEncryptionMethods, type KeyvEntry, KeyvEvents, KeyvHooks, KeyvJsonSerializer, type KeyvMapAny, type KeyvMapType, KeyvMemoryAdapter, type KeyvMemoryAdapterOptions, type KeyvMethods, type KeyvOptions, type KeyvProperties, KeyvSanitize, type KeyvSanitizeAdapter, type KeyvSanitizeOptions, type KeyvSanitizePatterns, type KeyvSerializationAdapter, type KeyvSerializationCapability, type KeyvSerializationMethods, KeyvStats, type KeyvStatsOptions, type KeyvStorageAdapter, type KeyvStorageCapability, type KeyvStorageGetResult, type KeyvStorageMethod, type KeyvStorageMethods, type KeyvStoreAdapter, type KeyvTelemetryEvent, type KeyvValue, type MethodType, createKeyv, detectKeyv, detectKeyvCompression, detectKeyvEncryption, detectKeyvSerialization, detectKeyvStorage, jsonSerializer };
+export { type DeserializedData, Keyv, Keyv as default, KeyvBridgeAdapter, type KeyvBridgeAdapterOptions, type KeyvBridgeStore, type KeyvCapability, type KeyvCompression, type KeyvCompressionAdapter, type KeyvCompressionCapability, type KeyvCompressionMethods, type KeyvEncryptionAdapter, type KeyvEncryptionCapability, type KeyvEncryptionMethods, type KeyvEntry, KeyvEvents, KeyvHooks, KeyvJsonSerializer, type KeyvMapAny, type KeyvMapType, KeyvMemoryAdapter, type KeyvMemoryAdapterOptions, type KeyvMethods, type KeyvOptions, type KeyvProperties, KeyvSanitize, type KeyvSanitizeAdapter, type KeyvSanitizeOptions, type KeyvSanitizePatterns, type KeyvSerializationAdapter, type KeyvSerializationCapability, type KeyvSerializationMethods, KeyvStats, type KeyvStatsOptions, type KeyvStorageAdapter, type KeyvStorageCapability, type KeyvStorageEntry, type KeyvStorageGetResult, type KeyvStorageMethod, type KeyvStorageMethods, type KeyvStoreAdapter, type KeyvTelemetryEvent, type KeyvValue, type MethodType, createKeyv, detectKeyv, detectKeyvCompression, detectKeyvEncryption, detectKeyvSerialization, detectKeyvStorage, jsonSerializer, keyvStorageCapability };