@buoy-gg/storage 1.7.2

package/lib/typescript/storage/utils/AsyncStorageListener.d.ts

@@ -0,0 +1,195 @@
+export interface AsyncStorageEvent {
+    action: "setItem" | "removeItem" | "mergeItem" | "clear" | "multiSet" | "multiRemove" | "multiMerge";
+    timestamp: Date;
+    data?: {
+        key?: string;
+        value?: string;
+        keys?: string[];
+        pairs?: [string, string][];
+    };
+}
+export type AsyncStorageEventListener = (event: AsyncStorageEvent) => void;
+/**
+ * Singleton class for intercepting and monitoring AsyncStorage operations
+ *
+ * This class uses method swizzling to intercept all AsyncStorage operations
+ * (setItem, removeItem, mergeItem, clear, multiSet, multiRemove, multiMerge)
+ * and emits events to registered listeners. It maintains the original functionality
+ * while providing observability for debugging and development tools.
+ *
+ * @example
+ * ```typescript
+ * // Start listening to all AsyncStorage operations
+ * startListening();
+ *
+ * // Add a listener for storage events
+ * const unsubscribe = addListener((event) => {
+ *   console.log(`${event.action}:`, event.data);
+ * });
+ *
+ * // Clean up
+ * unsubscribe();
+ * stopListening();
+ * ```
+ *
+ * @performance Uses method interception rather than polling for zero-overhead when inactive
+ * @performance Includes key filtering to prevent dev tools from triggering self-events
+ */
+declare class AsyncStorageListener {
+    private listeners;
+    private isListening;
+    private isInitialized;
+    private ignoredKeys;
+    private originalSetItem;
+    private originalRemoveItem;
+    private originalMergeItem;
+    private originalClear;
+    private originalMultiSet;
+    private originalMultiRemove;
+    private originalMultiMerge;
+    /**
+     * Determines if a storage key should be ignored to prevent infinite loops
+     *
+     * Dev tools often store their own state in AsyncStorage, which would trigger
+     * events and cause infinite loops or unnecessary noise.
+     *
+     * @param key - The storage key to check
+     * @returns True if the key should be ignored, false otherwise
+     */
+    private shouldIgnoreKey;
+    /**
+     * Initialize the listener by loading AsyncStorage and storing original methods
+     *
+     * This method performs safety checks to ensure we don't double-initialize
+     * and verifies that AsyncStorage methods haven't already been swizzled.
+     *
+     * @returns Promise<boolean> - True if initialization succeeded, false otherwise
+     *
+     * @throws Will log errors if AsyncStorage is already swizzled by another instance
+     */
+    private initialize;
+    /**
+     * Restore original AsyncStorage methods to their unmodified state
+     *
+     * This method undoes the method swizzling by restoring the original
+     * AsyncStorage methods that were saved during initialization.
+     */
+    private restoreOriginalMethods;
+    /**
+     * Emit an AsyncStorage event to all registered listeners
+     *
+     * @param event - The AsyncStorage event to emit
+     *
+     * @performance Skips processing when no listeners are registered
+     */
+    private emit;
+    /**
+     * Start intercepting AsyncStorage operations by swizzling methods
+     *
+     * This method replaces all AsyncStorage methods with wrapped versions
+     * that emit events while preserving the original functionality.
+     *
+     * @throws Will log errors if initialization fails or methods are already swizzled
+     *
+     * @performance Uses method swizzling for minimal runtime overhead
+     * @performance Includes safety checks to prevent double-initialization
+     */
+    startListening(): Promise<void>;
+    /**
+     * Stop listening and restore original AsyncStorage methods
+     *
+     * This method undoes all method swizzling and restores AsyncStorage
+     * to its original state.
+     */
+    stopListening(): void;
+    /**
+     * Add a listener for AsyncStorage events
+     *
+     * @param listener - Callback function to handle AsyncStorage events
+     * @returns Unsubscribe function to remove the listener
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = asyncStorageListener.addListener((event) => {
+     *   console.log('Storage operation:', event.action, event.data);
+     * });
+     *
+     * // Later, remove the listener
+     * unsubscribe();
+     * ```
+     */
+    addListener(listener: AsyncStorageEventListener): () => void;
+    /**
+     * Remove all registered event listeners
+     *
+     * Clears the internal listeners array, stopping all event notifications.
+     */
+    removeAllListeners(): void;
+    /**
+     * Check if the listener is currently active and intercepting operations
+     *
+     * @returns True if currently listening to AsyncStorage operations
+     */
+    get isActive(): boolean;
+    /**
+     * Get the number of currently registered event listeners
+     *
+     * @returns Number of active listeners
+     */
+    get listenerCount(): number;
+}
+/**
+ * Singleton instance of AsyncStorageListener
+ *
+ * This ensures only one listener instance exists across the entire application,
+ * preventing conflicts and duplicate event handling.
+ */
+declare const asyncStorageListener: AsyncStorageListener;
+/**
+ * Start listening to AsyncStorage operations
+ *
+ * @returns Promise that resolves when listening starts successfully
+ */
+export declare const startListening: () => Promise<void>;
+/**
+ * Stop listening to AsyncStorage operations
+ */
+export declare const stopListening: () => void;
+/**
+ * Add an event listener for AsyncStorage operations
+ *
+ * @param listener - Callback function to handle events
+ * @returns Unsubscribe function to remove the listener
+ */
+export declare const addListener: (listener: AsyncStorageEventListener) => () => void;
+/**
+ * Remove all registered event listeners
+ */
+export declare const removeAllListeners: () => void;
+/**
+ * Check if currently listening to AsyncStorage operations
+ *
+ * @returns True if actively intercepting AsyncStorage methods
+ */
+export declare const isListening: () => boolean;
+/**
+ * Get the current number of registered event listeners
+ *
+ * @returns Number of active listeners
+ */
+export declare const getListenerCount: () => number;
+/**
+ * Export the singleton instance for advanced usage
+ *
+ * @example
+ * ```typescript
+ * import asyncStorageListener from './AsyncStorageListener';
+ *
+ * // Access advanced methods directly
+ * if (asyncStorageListener.isActive) {
+ *   console.log(`${asyncStorageListener.listenerCount} listeners active`);
+ * }
+ * ```
+ */
+export default asyncStorageListener;
+//# sourceMappingURL=AsyncStorageListener.d.ts.map

package/lib/typescript/storage/utils/AsyncStorageListener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncStorageListener.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/AsyncStorageListener.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,iBAAiB;IAChC,MAAM,EACF,SAAS,GACT,YAAY,GACZ,WAAW,GACX,OAAO,GACP,UAAU,GACV,aAAa,GACb,YAAY,CAAC;IACjB,SAAS,EAAE,IAAI,CAAC;IAChB,IAAI,CAAC,EAAE;QACL,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;KAC5B,CAAC;CACH;AAED,MAAM,MAAM,yBAAyB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,cAAM,oBAAoB;IACxB,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,aAAa,CAAS;IAI9B,OAAO,CAAC,WAAW,CAKhB;IAGH,OAAO,CAAC,eAAe,CAAoC;IAC3D,OAAO,CAAC,kBAAkB,CAAuC;IACjE,OAAO,CAAC,iBAAiB,CAAsC;IAC/D,OAAO,CAAC,aAAa,CAAkC;IACvD,OAAO,CAAC,gBAAgB,CAAqC;IAC7D,OAAO,CAAC,mBAAmB,CAAwC;IACnE,OAAO,CAAC,kBAAkB,CAAuC;IAEjE;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe;IAYvB;;;;;;;;;OASG;YACW,UAAU;IAiCxB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IA0B9B;;;;;;OAMG;IACH,OAAO,CAAC,IAAI;IAeZ;;;;;;;;;;OAUG;IACG,cAAc;IAmLpB;;;;;OAKG;IACH,aAAa;IAsCb;;;;;;;;;;;;;;;OAeG;IACH,WAAW,CAAC,QAAQ,EAAE,yBAAyB;IAY/C;;;;OAIG;IACH,kBAAkB;IAKlB;;;;OAIG;IACH,IAAI,QAAQ,YAEX;IAED;;;;OAIG;IACH,IAAI,aAAa,WAEhB;CACF;AAED;;;;;GAKG;AACH,QAAA,MAAM,oBAAoB,sBAA6B,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,cAAc,qBAA8C,CAAC;AAE1E;;GAEG;AACH,eAAO,MAAM,aAAa,YAA6C,CAAC;AAExE;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,UAAU,yBAAyB,eACnB,CAAC;AAE7C;;GAEG;AACH,eAAO,MAAM,kBAAkB,YACY,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,WAAW,eAAsC,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,cAA2C,CAAC;AAEzE;;;;;;;;;;;;GAYG;AACH,eAAe,oBAAoB,CAAC"}

package/lib/typescript/storage/utils/MMKVInstanceRegistry.d.ts

@@ -0,0 +1,224 @@
+/**
+ * MMKV Instance Registry
+ *
+ * Centralized registry for tracking all MMKV instances in the application.
+ * Provides a singleton pattern to manage multiple MMKV instances and their metadata.
+ *
+ * @module MMKVInstanceRegistry
+ * @since 1.0.0
+ */
+/**
+ * Type-safe representation of an MMKV instance.
+ * Uses conditional typing to avoid hard dependency on react-native-mmkv.
+ *
+ * @public
+ */
+export type MMKV = {
+    /**
+     * Set a value for the given key
+     */
+    set(key: string, value: boolean | string | number | ArrayBuffer): void;
+    /**
+     * Get a string value for the given key
+     */
+    getString(key: string): string | undefined;
+    /**
+     * Get a number value for the given key
+     */
+    getNumber(key: string): number | undefined;
+    /**
+     * Get a boolean value for the given key
+     */
+    getBoolean(key: string): boolean | undefined;
+    /**
+     * Get a buffer value for the given key
+     */
+    getBuffer(key: string): ArrayBuffer | undefined;
+    /**
+     * Check if a key exists
+     */
+    contains(key: string): boolean;
+    /**
+     * Delete a key (v4 uses 'remove', but we support both)
+     */
+    delete?(key: string): boolean;
+    remove?(key: string): void;
+    /**
+     * Get all keys
+     */
+    getAllKeys(): string[];
+    /**
+     * Clear all data
+     */
+    clearAll(): void;
+    /**
+     * Trim storage to reclaim disk space
+     */
+    trim?(): void;
+    /**
+     * Whether this instance is read-only
+     */
+    readonly isReadOnly?: boolean;
+    /**
+     * Current storage size in bytes
+     */
+    readonly size: number;
+};
+/**
+ * Metadata about a registered MMKV instance
+ *
+ * @public
+ */
+export interface MMKVInstanceInfo {
+    /**
+     * Unique identifier for this MMKV instance
+     * @example "mmkv.default", "user-preferences", "secure-storage"
+     */
+    id: string;
+    /**
+     * The MMKV instance object
+     */
+    instance: MMKV;
+    /**
+     * Whether this instance uses encryption
+     * @default false
+     */
+    encrypted: boolean;
+    /**
+     * Whether this instance is read-only
+     * @default false
+     */
+    readOnly: boolean;
+}
+/**
+ * Configuration options for registering an MMKV instance
+ *
+ * @public
+ */
+export interface MMKVRegistrationConfig {
+    /**
+     * Whether this instance uses encryption
+     * Set to true if you provided an encryptionKey when creating the instance
+     * @default false
+     */
+    encrypted?: boolean;
+}
+declare class MMKVInstanceRegistry {
+    private instances;
+    /**
+     * Register an MMKV instance for monitoring
+     *
+     * @param id - Unique identifier for this instance
+     * @param instance - The MMKV instance to register
+     * @param config - Optional configuration (e.g., encrypted flag)
+     */
+    register(id: string, instance: MMKV, config?: MMKVRegistrationConfig): void;
+    /**
+     * Unregister an MMKV instance
+     */
+    unregister(id: string): void;
+    /**
+     * Get a specific instance by ID
+     */
+    get(id: string): MMKVInstanceInfo | undefined;
+    /**
+     * Get all registered instances
+     */
+    getAll(): MMKVInstanceInfo[];
+    /**
+     * Check if an instance is registered
+     */
+    has(id: string): boolean;
+    /**
+     * Get count of registered instances
+     */
+    count(): number;
+}
+export declare const mmkvInstanceRegistry: MMKVInstanceRegistry;
+/**
+ * Register an MMKV instance with React Buoy DevTools for monitoring and debugging.
+ *
+ * **⚠️ REQUIRED**: Manual registration is required for `react-native-mmkv` v4.
+ * Auto-detection is not possible due to Metro bundler and ES6 module limitations.
+ *
+ * Call this function immediately after creating each MMKV instance you want to monitor.
+ * The DevTools will then be able to:
+ * - Display all keys and values
+ * - Show real-time updates when data changes
+ * - Allow editing values directly from the DevTools
+ * - Track storage size and performance
+ *
+ * @param id - Unique identifier for this MMKV instance. Should match the `id` you used when creating the instance.
+ * @param instance - The MMKV instance returned from `createMMKV()`
+ * @param config - Optional configuration
+ * @param config.encrypted - Set to `true` if this instance uses encryption (has an `encryptionKey`)
+ *
+ * @example
+ * **Basic usage:**
+ * ```typescript
+ * import { createMMKV } from 'react-native-mmkv';
+ * import { registerMMKVInstance } from '@buoy-gg/storage';
+ *
+ * // Create and register default instance
+ * export const storage = createMMKV({ id: 'mmkv.default' });
+ * registerMMKVInstance('mmkv.default', storage);
+ * ```
+ *
+ * @example
+ * **With encryption:**
+ * ```typescript
+ * import { createMMKV } from 'react-native-mmkv';
+ * import { registerMMKVInstance } from '@buoy-gg/storage';
+ *
+ * // Create encrypted instance
+ * export const secureStorage = createMMKV({
+ *   id: 'secure-storage',
+ *   encryptionKey: 'my-encryption-key'
+ * });
+ *
+ * // Register with encrypted flag
+ * registerMMKVInstance('secure-storage', secureStorage, { encrypted: true });
+ * ```
+ *
+ * @example
+ * **Multiple instances:**
+ * ```typescript
+ * import { createMMKV } from 'react-native-mmkv';
+ * import { registerMMKVInstance } from '@buoy-gg/storage';
+ *
+ * // User preferences
+ * export const userPrefs = createMMKV({ id: 'user-prefs' });
+ * registerMMKVInstance('user-prefs', userPrefs);
+ *
+ * // Cache
+ * export const cache = createMMKV({ id: 'cache' });
+ * registerMMKVInstance('cache', cache);
+ *
+ * // Auth (encrypted)
+ * export const auth = createMMKV({ id: 'auth', encryptionKey: 'key' });
+ * registerMMKVInstance('auth', auth, { encrypted: true });
+ * ```
+ *
+ * @public
+ * @since 1.0.0
+ */
+export declare function registerMMKVInstance(id: string, instance: MMKV, config?: MMKVRegistrationConfig): void;
+/**
+ * Unregister an MMKV instance from DevTools monitoring.
+ *
+ * This stops the DevTools from tracking changes to this instance.
+ * Typically not needed unless you're dynamically creating/destroying instances.
+ *
+ * @param id - The instance ID to unregister
+ *
+ * @example
+ * ```typescript
+ * unregisterMMKVInstance('cache');
+ * ```
+ *
+ * @public
+ * @since 1.0.0
+ */
+export declare function unregisterMMKVInstance(id: string): void;
+export {};
+//# sourceMappingURL=MMKVInstanceRegistry.d.ts.map

package/lib/typescript/storage/utils/MMKVInstanceRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MMKVInstanceRegistry.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/MMKVInstanceRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,IAAI,GAAG;IACjB;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,GAAG,IAAI,CAAC;IACvE;;OAEG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC3C;;OAEG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC3C;;OAEG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;IAC7C;;OAEG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IAChD;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B;;OAEG;IACH,MAAM,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9B,MAAM,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;OAEG;IACH,UAAU,IAAI,MAAM,EAAE,CAAC;IACvB;;OAEG;IACH,QAAQ,IAAI,IAAI,CAAC;IACjB;;OAEG;IACH,IAAI,CAAC,IAAI,IAAI,CAAC;IACd;;OAEG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;OAEG;IACH,QAAQ,EAAE,IAAI,CAAC;IACf;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,cAAM,oBAAoB;IACxB,OAAO,CAAC,SAAS,CAAuC;IAExD;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,sBAAsB,GAAG,IAAI;IAU3E;;OAEG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAI5B;;OAEG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAI7C;;OAEG;IACH,MAAM,IAAI,gBAAgB,EAAE;IAI5B;;OAEG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB;;OAEG;IACH,KAAK,IAAI,MAAM;CAGhB;AAGD,eAAO,MAAM,oBAAoB,sBAA6B,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,IAAI,EACd,MAAM,CAAC,EAAE,sBAAsB,GAC9B,IAAI,CASN;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAOvD"}

package/lib/typescript/storage/utils/MMKVListener.d.ts

@@ -0,0 +1,218 @@
+/**
+ * MMKVListener - Hybrid Monitoring Strategy
+ *
+ * This module provides comprehensive monitoring for MMKV storage instances using
+ * a hybrid approach that combines:
+ *
+ * 1. MMKV's built-in addOnValueChangedListener() - for write operations
+ * 2. Method wrapping - for read operations and type detection
+ *
+ * Why Hybrid Strategy?
+ * - MMKV listeners only fire on writes (set/delete), not reads
+ * - MMKV listeners don't provide value type information
+ * - Method wrapping captures ALL operations with full context
+ * - Combining both gives complete observability
+ *
+ * Key Differences from AsyncStorage:
+ * - Synchronous API (no async/await needed)
+ * - Multi-instance support (track multiple MMKV instances)
+ * - Native types (string, number, boolean, buffer)
+ * - Built-in listener support (MMKV.addOnValueChangedListener)
+ *
+ * @see AsyncStorageListener.ts for AsyncStorage equivalent
+ */
+type MMKV = any;
+import { MMKVValueType } from "./mmkvTypeDetection";
+/**
+ * Event types for MMKV operations
+ */
+export interface MMKVEvent {
+    action: "set.string" | "set.number" | "set.boolean" | "set.buffer" | "delete" | "clearAll" | "get.string" | "get.number" | "get.boolean" | "get.buffer";
+    timestamp: Date;
+    instanceId: string;
+    data?: {
+        key?: string;
+        value?: any;
+        valueType?: MMKVValueType;
+        success?: boolean;
+    };
+}
+export type MMKVEventListener = (event: MMKVEvent) => void;
+/**
+ * Singleton class for monitoring MMKV operations across multiple instances
+ *
+ * Uses a hybrid monitoring strategy:
+ * 1. MMKV's built-in listener API for write notifications
+ * 2. Method wrapping for read operations and type information
+ *
+ * @example
+ * ```typescript
+ * import { MMKV } from 'react-native-mmkv';
+ * import { mmkvListener } from './MMKVListener';
+ *
+ * const storage = new MMKV();
+ *
+ * // Start monitoring this instance
+ * mmkvListener.addInstance(storage, 'mmkv.default');
+ *
+ * // Add listener for all MMKV events
+ * const unsubscribe = mmkvListener.addListener((event) => {
+ *   console.log(`[${event.instanceId}] ${event.action}:`, event.data);
+ * });
+ *
+ * // Cleanup
+ * unsubscribe();
+ * mmkvListener.removeInstance('mmkv.default');
+ * ```
+ */
+declare class MMKVListener {
+    private listeners;
+    private instances;
+    private ignoredKeys;
+    /**
+     * Determines if a storage key should be ignored
+     */
+    private shouldIgnoreKey;
+    /**
+     * Emit an MMKV event to all registered listeners
+     */
+    private emit;
+    /**
+     * Add an MMKV instance for monitoring
+     *
+     * This method sets up both native MMKV listeners and method wrapping
+     * to provide complete observability.
+     *
+     * @param instance - MMKV instance to monitor
+     * @param instanceId - Unique identifier for this instance
+     *
+     * @example
+     * ```typescript
+     * const storage = new MMKV();
+     * mmkvListener.addInstance(storage, 'mmkv.default');
+     *
+     * const secureStorage = new MMKV({ id: 'secure', encryptionKey: key });
+     * mmkvListener.addInstance(secureStorage, 'secure');
+     * ```
+     */
+    addInstance(instance: MMKV, instanceId: string): void;
+    /**
+     * Remove an MMKV instance from monitoring
+     *
+     * Restores original methods and removes native listener.
+     *
+     * @param instanceId - Identifier of instance to stop monitoring
+     */
+    removeInstance(instanceId: string): void;
+    /**
+     * Remove all monitored instances
+     */
+    removeAllInstances(): void;
+    /**
+     * Add a listener for MMKV events across all monitored instances
+     *
+     * @param listener - Callback function to handle MMKV events
+     * @returns Unsubscribe function to remove the listener
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = mmkvListener.addListener((event) => {
+     *   console.log(`[${event.instanceId}] ${event.action}:`, event.data);
+     * });
+     *
+     * // Later, remove the listener
+     * unsubscribe();
+     * ```
+     */
+    addListener(listener: MMKVEventListener): () => void;
+    /**
+     * Remove all registered event listeners
+     */
+    removeAllListeners(): void;
+    /**
+     * Check if an instance is currently being monitored
+     */
+    hasInstance(instanceId: string): boolean;
+    /**
+     * Get list of all monitored instance IDs
+     */
+    getMonitoredInstances(): string[];
+    /**
+     * Get the number of currently monitored instances
+     */
+    get instanceCount(): number;
+    /**
+     * Get the number of currently registered event listeners
+     */
+    get listenerCount(): number;
+    /**
+     * Check if any instances are being monitored
+     */
+    get isActive(): boolean;
+}
+/**
+ * Singleton instance of MMKVListener
+ *
+ * This ensures only one listener manager exists across the entire application.
+ */
+export declare const mmkvListener: MMKVListener;
+/**
+ * Add an MMKV instance for monitoring
+ *
+ * @param instance - MMKV instance to monitor
+ * @param instanceId - Unique identifier for this instance
+ *
+ * @example
+ * ```typescript
+ * import { MMKV } from 'react-native-mmkv';
+ * import { addMMKVInstance } from '@buoy-gg/storage';
+ *
+ * const storage = new MMKV();
+ * addMMKVInstance(storage, 'mmkv.default');
+ * ```
+ */
+export declare const addMMKVInstance: (instance: MMKV, instanceId: string) => void;
+/**
+ * Remove an MMKV instance from monitoring
+ */
+export declare const removeMMKVInstance: (instanceId: string) => void;
+/**
+ * Remove all monitored MMKV instances
+ */
+export declare const removeAllMMKVInstances: () => void;
+/**
+ * Add an event listener for MMKV operations
+ *
+ * @param listener - Callback function to handle events
+ * @returns Unsubscribe function to remove the listener
+ */
+export declare const addMMKVListener: (listener: MMKVEventListener) => () => void;
+/**
+ * Remove all registered event listeners
+ */
+export declare const removeAllMMKVListeners: () => void;
+/**
+ * Check if an MMKV instance is currently being monitored
+ */
+export declare const isMMKVInstanceMonitored: (instanceId: string) => boolean;
+/**
+ * Get list of all monitored MMKV instance IDs
+ */
+export declare const getMonitoredMMKVInstances: () => string[];
+/**
+ * Get the current number of monitored MMKV instances
+ */
+export declare const getMMKVInstanceCount: () => number;
+/**
+ * Get the current number of registered event listeners
+ */
+export declare const getMMKVListenerCount: () => number;
+/**
+ * Check if any MMKV instances are being monitored
+ */
+export declare const isMMKVListening: () => boolean;
+/**
+ * Export the singleton instance for advanced usage
+ */
+export default mmkvListener;
+//# sourceMappingURL=MMKVListener.d.ts.map

package/lib/typescript/storage/utils/MMKVListener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MMKVListener.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/MMKVListener.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,KAAK,IAAI,GAAG,GAAG,CAAC;AAChB,OAAO,EAAkB,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAcpE;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,MAAM,EACF,YAAY,GACZ,YAAY,GACZ,aAAa,GACb,YAAY,GACZ,QAAQ,GACR,UAAU,GACV,YAAY,GACZ,YAAY,GACZ,aAAa,GACb,YAAY,CAAC;IACjB,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE;QACL,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,GAAG,CAAC;QACZ,SAAS,CAAC,EAAE,aAAa,CAAC;QAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;CACH;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;AAyB3D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,cAAM,YAAY;IAChB,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,SAAS,CAA2C;IAG5D,OAAO,CAAC,WAAW,CAKhB;IAEH;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACH,OAAO,CAAC,IAAI;IAYZ;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IA+ErD;;;;;;OAMG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAiBxC;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAK1B;;;;;;;;;;;;;;;OAeG;IACH,WAAW,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI;IAYpD;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAI1B;;OAEG;IACH,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAIxC;;OAEG;IACH,qBAAqB,IAAI,MAAM,EAAE;IAIjC;;OAEG;IACH,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED;;OAEG;IACH,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,OAAO,CAEtB;CACF;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,cAAqB,CAAC;AAE/C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,IAAI,EAAE,YAAY,MAAM,SAClB,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,YAAY,MAAM,SACZ,CAAC;AAE1C;;GAEG;AACH,eAAO,MAAM,sBAAsB,YAA0C,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,iBAAiB,WAjGT,IAkGd,CAAC;AAErC;;GAEG;AACH,eAAO,MAAM,sBAAsB,YAA0C,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAAI,YAAY,MAAM,YACpB,CAAC;AAEvC;;GAEG;AACH,eAAO,MAAM,yBAAyB,gBACA,CAAC;AAEvC;;GAEG;AACH,eAAO,MAAM,oBAAoB,cAAmC,CAAC;AAErE;;GAEG;AACH,eAAO,MAAM,oBAAoB,cAAmC,CAAC;AAErE;;GAEG;AACH,eAAO,MAAM,eAAe,eAA8B,CAAC;AAE3D;;GAEG;AACH,eAAe,YAAY,CAAC"}

package/lib/typescript/storage/utils/clearAllStorage.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Clear all storage data except dev tools keys
+ * This preserves dev tool settings while clearing app data
+ */
+export declare function clearAllAppStorage(): Promise<void>;
+/**
+ * Clear absolutely all storage data including dev tools
+ * Use with caution - this will reset all dev tool settings
+ */
+export declare function clearAllStorageIncludingDevTools(): Promise<void>;
+//# sourceMappingURL=clearAllStorage.d.ts.map

package/lib/typescript/storage/utils/clearAllStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearAllStorage.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/clearAllStorage.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAyBxD;AAED;;;GAGG;AACH,wBAAsB,gCAAgC,IAAI,OAAO,CAAC,IAAI,CAAC,CAKtE"}

package/lib/typescript/storage/utils/index.d.ts

@@ -0,0 +1,8 @@
+export { clearAllAppStorage } from "./clearAllStorage";
+export { isMMKVAvailable, getMMKVClass, getMMKVUnavailableMessage, } from "./mmkvAvailability";
+export { startListening, stopListening, addListener, removeAllListeners, isListening, getListenerCount, type AsyncStorageEvent, type AsyncStorageEventListener, } from "./AsyncStorageListener";
+export { default as asyncStorageListener } from "./AsyncStorageListener";
+export { registerMMKVInstance, unregisterMMKVInstance, mmkvInstanceRegistry, type MMKVInstanceInfo, } from "./MMKVInstanceRegistry";
+export { addMMKVInstance, removeMMKVInstance, removeAllMMKVInstances, addMMKVListener, removeAllMMKVListeners, isMMKVInstanceMonitored, getMonitoredMMKVInstances, getMMKVInstanceCount, getMMKVListenerCount, isMMKVListening, mmkvListener, type MMKVEvent, type MMKVEventListener, } from "./MMKVListener";
+export { detectMMKVType, formatMMKVValue, isTypeMatch, type MMKVValueType, type MMKVValueInfo, } from "./mmkvTypeDetection";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/storage/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAGvD,OAAO,EACL,eAAe,EACf,YAAY,EACZ,yBAAyB,GAC1B,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,cAAc,EACd,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,WAAW,EACX,gBAAgB,EAChB,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,GAC/B,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGzE,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,KAAK,gBAAgB,GACtB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,sBAAsB,EACtB,eAAe,EACf,sBAAsB,EACtB,uBAAuB,EACvB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,YAAY,EACZ,KAAK,SAAS,EACd,KAAK,iBAAiB,GACvB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,cAAc,EACd,eAAe,EACf,WAAW,EACX,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC"}