@openclaw/whatsapp 2026.7.1-beta.2 → 2026.7.1-beta.4

package/node_modules/cacheable/dist/index.d.ts

@@ -1,494 +0,0 @@
-import { Stats, CacheableItem, WrapFunctionOptions, GetOrSetKey, GetOrSetFunctionOptions, HashAlgorithm } from '@cacheable/utils';
-export { CacheableItem, Stats as CacheableStats, GetOrSetFunctionOptions, GetOrSetKey, GetOrSetOptions, HashAlgorithm, WrapOptions, WrapSyncOptions, calculateTtlFromExpiration, getCascadingTtl, getOrSet, hash, shorthandToMilliseconds, shorthandToTime, wrap, wrapSync } from '@cacheable/utils';
-import { Hookified, HookifiedOptions } from 'hookified';
-import { Keyv, KeyvStoreAdapter, StoredDataRaw } from 'keyv';
-export { Keyv, KeyvHooks, KeyvOptions, KeyvStoreAdapter } from 'keyv';
-import { Qified, MessageProvider } from 'qified';
-export { CacheableMemory, CacheableMemoryOptions, KeyvCacheableMemory, KeyvCacheableMemoryOptions, createKeyv } from '@cacheable/memory';
-
-/**
- * Events emitted by CacheableSync
- */
-declare enum CacheableSyncEvents {
-    ERROR = "error",
-    SET = "cache:set",
-    DELETE = "cache:delete"
-}
-/**
- * Configuration options for CacheableSync
- */
-type CacheableSyncOptions = {
-    /**
-     * Qified instance or message provider(s) for synchronization
-     */
-    qified: Qified | MessageProvider | MessageProvider[];
-    /**
-     * The namespace for sync events. It can be a string or a function that returns a string.
-     * When set, event names will be prefixed with the namespace (e.g., "my-namespace::cache:set")
-     */
-    namespace?: string | (() => string);
-} & HookifiedOptions;
-type CacheableSyncItem = {
-    cacheId: string;
-    key: string;
-    value?: unknown;
-    ttl?: number;
-};
-/**
- * CacheableSync provides synchronization capabilities for cacheable items
- * using message providers from Qified
- */
-declare class CacheableSync extends Hookified {
-    private _qified;
-    private _namespace?;
-    private _storage?;
-    private _cacheId?;
-    /**
-     * Creates an instance of CacheableSync
-     * @param options - Configuration options for CacheableSync
-     */
-    constructor(options: CacheableSyncOptions);
-    /**
-     * Gets the Qified instance used for synchronization
-     * @returns The Qified instance
-     */
-    get qified(): Qified;
-    /**
-     * Sets the Qified instance used for synchronization
-     * @param value - Either an existing Qified instance or MessageProvider(s)
-     */
-    set qified(value: Qified | MessageProvider | MessageProvider[]);
-    /**
-     * Gets the namespace for sync events
-     * @returns The namespace or undefined if not set
-     */
-    get namespace(): string | (() => string) | undefined;
-    /**
-     * Sets the namespace for sync events and resubscribes if needed
-     * @param namespace - The namespace string or function
-     */
-    set namespace(namespace: string | (() => string) | undefined);
-    /**
-     * Publishes a cache event to all the cache instances
-     * @param data - The cache item data containing cacheId, key, value, and optional ttl
-     */
-    publish(event: CacheableSyncEvents, data: CacheableSyncItem): Promise<void>;
-    /**
-     * Subscribes to sync events and updates the provided storage
-     * @param storage - The Keyv storage instance to update
-     * @param cacheId - The cache ID to identify this instance
-     */
-    subscribe(storage: Keyv, cacheId: string): void;
-    /**
-     * Creates or returns a Qified instance from the provided value
-     * @param value - Either an existing Qified instance or MessageProvider(s)
-     * @returns A Qified instance configured with the provided message provider(s)
-     */
-    createQified(value: Qified | MessageProvider | MessageProvider[]): Qified;
-    /**
-     * Gets the namespace prefix to use for event names
-     * @returns The resolved namespace string or undefined
-     */
-    private getNamespace;
-    /**
-     * Prefixes an event name with the namespace if one is set
-     * @param event - The event to prefix
-     * @returns The prefixed event name or the original event
-     */
-    private getPrefixedEvent;
-}
-
-type CacheableOptions = {
-    /**
-     * The primary store for the cacheable instance
-     */
-    primary?: Keyv | KeyvStoreAdapter;
-    /**
-     * The secondary store for the cacheable instance
-     */
-    secondary?: Keyv | KeyvStoreAdapter;
-    /**
-     * Whether to enable statistics for the cacheable instance
-     */
-    stats?: boolean;
-    /**
-     * Whether the secondary store is non-blocking mode. It is set to false by default.
-     * If it is set to true then the secondary store will not block the primary store.
-     */
-    nonBlocking?: boolean;
-    /**
-     * The time-to-live for the cacheable instance and will be used as the default value.
-     * can be a number in milliseconds or a human-readable format such as `1s` for 1 second or `1h` for 1 hour
-     * or undefined if there is no time-to-live.
-     */
-    ttl?: number | string;
-    /**
-     * The namespace for the cacheable instance. It can be a string or a function that returns a string.
-     */
-    namespace?: string | (() => string);
-    /**
-     * The cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
-     * If it is not set then it will be a random string that is generated
-     */
-    cacheId?: string;
-    /**
-     * The sync instance for the cacheable instance to enable synchronization across cache instances
-     */
-    sync?: CacheableSync | CacheableSyncOptions;
-};
-type GetOptions = {
-    /**
-     * If set, this will bypass the instances nonBlocking setting.
-     * @type {boolean}
-     */
-    nonBlocking?: boolean;
-};
-
-declare enum CacheableHooks {
-    BEFORE_SET = "BEFORE_SET",
-    AFTER_SET = "AFTER_SET",
-    BEFORE_SET_MANY = "BEFORE_SET_MANY",
-    AFTER_SET_MANY = "AFTER_SET_MANY",
-    BEFORE_GET = "BEFORE_GET",
-    AFTER_GET = "AFTER_GET",
-    BEFORE_GET_MANY = "BEFORE_GET_MANY",
-    AFTER_GET_MANY = "AFTER_GET_MANY",
-    BEFORE_SECONDARY_SETS_PRIMARY = "BEFORE_SECONDARY_SETS_PRIMARY"
-}
-declare enum CacheableEvents {
-    ERROR = "error",
-    CACHE_HIT = "cache:hit",
-    CACHE_MISS = "cache:miss"
-}
-
-declare class Cacheable extends Hookified {
-    private _primary;
-    private _secondary;
-    private _nonBlocking;
-    private _ttl?;
-    private readonly _stats;
-    private _namespace?;
-    private _cacheId;
-    private _sync?;
-    /**
-     * Creates a new cacheable instance
-     * @param {CacheableOptions} [options] The options for the cacheable instance
-     */
-    constructor(options?: CacheableOptions);
-    /**
-     * The namespace for the cacheable instance
-     * @returns {string | (() => string) | undefined} The namespace for the cacheable instance
-     */
-    get namespace(): string | (() => string) | undefined;
-    /**
-     * Sets the namespace for the cacheable instance
-     * @param {string | (() => string) | undefined} namespace The namespace for the cacheable instance
-     * @returns {void}
-     */
-    set namespace(namespace: string | (() => string) | undefined);
-    /**
-     * The statistics for the cacheable instance
-     * @returns {CacheableStats} The statistics for the cacheable instance
-     */
-    get stats(): Stats;
-    /**
-     * The primary store for the cacheable instance
-     * @returns {Keyv} The primary store for the cacheable instance
-     */
-    get primary(): Keyv;
-    /**
-     * Sets the primary store for the cacheable instance
-     * @param {Keyv} primary The primary store for the cacheable instance
-     */
-    set primary(primary: Keyv);
-    /**
-     * The secondary store for the cacheable instance
-     * @returns {Keyv | undefined} The secondary store for the cacheable instance
-     */
-    get secondary(): Keyv | undefined;
-    /**
-     * Sets the secondary store for the cacheable instance. If it is set to undefined then the secondary store is disabled.
-     * @param {Keyv | undefined} secondary The secondary store for the cacheable instance
-     * @returns {void}
-     */
-    set secondary(secondary: Keyv | undefined);
-    /**
-     * Gets whether the secondary store is non-blocking mode. It is set to false by default.
-     * If it is set to true then the secondary store will not block the primary store.
-     *
-     * [Learn more about non-blocking mode](https://cacheable.org/docs/cacheable/#non-blocking-operations).
-     *
-     * @returns {boolean} Whether the cacheable instance is non-blocking
-     */
-    get nonBlocking(): boolean;
-    /**
-     * Sets whether the secondary store is non-blocking mode. It is set to false by default.
-     * If it is set to true then the secondary store will not block the primary store.
-     *
-     * [Learn more about non-blocking mode](https://cacheable.org/docs/cacheable/#non-blocking-operations).
-     *
-     * @param {boolean} nonBlocking Whether the cacheable instance is non-blocking
-     * @returns {void}
-     */
-    set nonBlocking(nonBlocking: boolean);
-    /**
-     * The time-to-live for the cacheable instance and will be used as the default value.
-     * can be a number in milliseconds or a human-readable format such as `1s` for 1 second or `1h` for 1 hour
-     * or undefined if there is no time-to-live.
-     *
-     * [Learn more about time-to-live](https://cacheable.org/docs/cacheable/#shorthand-for-time-to-live-ttl).
-     *
-     * @returns {number | string | undefined} The time-to-live for the cacheable instance in milliseconds, human-readable format or undefined
-     * @example
-     * ```typescript
-     * const cacheable = new Cacheable({ ttl: '1h' });
-     * console.log(cacheable.ttl); // 1h
-     * ```
-     */
-    get ttl(): number | string | undefined;
-    /**
-     * Sets the time-to-live for the cacheable instance and will be used as the default value.
-     * If you set a number it is miliseconds, if you set a string it is a human-readable
-     * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that
-     * there is no time-to-live.
-     *
-     * [Learn more about time-to-live](https://cacheable.org/docs/cacheable/#shorthand-for-time-to-live-ttl).
-     *
-     * @param {number | string | undefined} ttl The time-to-live for the cacheable instance
-     * @example
-     * ```typescript
-     * const cacheable = new Cacheable();
-     * cacheable.ttl = '1h'; // Set the time-to-live to 1 hour
-     * ```
-     * or setting the time-to-live in milliseconds
-     * ```typescript
-     * const cacheable = new Cacheable();
-     * cacheable.ttl = 3600000; // Set the time-to-live to 1 hour
-     * ```
-     */
-    set ttl(ttl: number | string | undefined);
-    /**
-     * The cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
-     * If it is not set then it will be a random string that is generated
-     * @returns {string} The cacheId for the cacheable instance
-     */
-    get cacheId(): string;
-    /**
-     * Sets the cacheId for the cacheable instance. This is primarily used for the wrap function to not have conflicts.
-     * If it is not set then it will be a random string that is generated
-     * @param {string} cacheId The cacheId for the cacheable instance
-     */
-    set cacheId(cacheId: string);
-    /**
-     * Gets the sync instance for the cacheable instance
-     * @returns {CacheableSync | undefined} The sync instance for the cacheable instance
-     */
-    get sync(): CacheableSync | undefined;
-    /**
-     * Sets the sync instance for the cacheable instance
-     * @param {CacheableSync | undefined} sync The sync instance for the cacheable instance
-     */
-    set sync(sync: CacheableSync | undefined);
-    /**
-     * Sets the primary store for the cacheable instance
-     * @param {Keyv | KeyvStoreAdapter} primary The primary store for the cacheable instance
-     * @returns {void}
-     */
-    setPrimary(primary: Keyv | KeyvStoreAdapter): void;
-    /**
-     * Sets the secondary store for the cacheable instance. If it is set to undefined then the secondary store is disabled.
-     * @param {Keyv | KeyvStoreAdapter} secondary The secondary store for the cacheable instance
-     * @returns {void}
-     */
-    setSecondary(secondary: Keyv | KeyvStoreAdapter): void;
-    getNameSpace(): string | undefined;
-    /**
-     * Retrieves an entry from the cache.
-     *
-     * Checks the primary store first; if not found and a secondary store is configured,
-     * it will fetch from the secondary, repopulate the primary, and return the result.
-     *
-     * @typeParam T - The expected type of the stored value.
-     * @param {string} key - The cache key to retrieve.
-     * @param {GetOptions} - options such as to bypass `nonBlocking` for this call
-     * @returns {Promise<T | undefined>}
-     *   A promise that resolves to the cached value if found, or `undefined`.
-     */
-    get<T>(key: string, options?: GetOptions): Promise<T | undefined>;
-    /**
-     * Retrieves the raw entry from the cache including metadata like expiration.
-     *
-     * Checks the primary store first; if not found and a secondary store is configured,
-     * it will fetch from the secondary, repopulate the primary, and return the result.
-     *
-     * @typeParam T - The expected type of the stored value.
-     * @param {string} key - The cache key to retrieve.
-     * @param {GetOptions} - options such as to bypass `nonBlocking` for this call
-     * @returns {Promise<StoredDataRaw<T>>}
-     *   A promise that resolves to the full raw data object if found, or undefined.
-     */
-    getRaw<T>(key: string, options?: GetOptions): Promise<StoredDataRaw<T>>;
-    /**
-     * Retrieves multiple raw entries from the cache including metadata like expiration.
-     *
-     * Checks the primary store for each key; if a key is missing and a secondary store is configured,
-     * it will fetch from the secondary store, repopulate the primary store, and return the results.
-     *
-     * @typeParam T - The expected type of the stored values.
-     * @param {string[]} keys - The cache keys to retrieve.
-     * @param {GetOptions} - options such as to bypass `nonBlocking` on this call
-     * @returns {Promise<Array<StoredDataRaw<T>>>}
-     *   A promise that resolves to an array of raw data objects.
-     */
-    getManyRaw<T>(keys: string[], options?: GetOptions): Promise<Array<StoredDataRaw<T>>>;
-    /**
-     * Retrieves multiple entries from the cache.
-     * Checks the primary store for each key; if a key is missing and a secondary store is configured,
-     * it will fetch from the secondary store, repopulate the primary store, and return the results.
-     *
-     * @typeParam T - The expected type of the stored values.
-     * @param {string[]} keys - The cache keys to retrieve.
-     * @param {GetOptions} - options such as to bypass `nonBlocking` on this call
-     * @returns {Promise<Array<T | undefined>>}
-     *   A promise that resolves to an array of cached values or `undefined` for misses.
-     */
-    getMany<T>(keys: string[], options?: GetOptions): Promise<Array<T | undefined>>;
-    /**
-     * Sets the value of the key. If the secondary store is set then it will also set the value in the secondary store.
-     * @param {string} key the key to set the value of
-     * @param {T} value The value to set
-     * @param {number | string} [ttl] set a number it is miliseconds, set a string it is a human-readable
-     * format such as `1s` for 1 second or `1h` for 1 hour. Setting undefined means that it will use the default time-to-live.
-     * @returns {boolean} Whether the value was set
-     */
-    set<T>(key: string, value: T, ttl?: number | string): Promise<boolean>;
-    /**
-     * Sets the values of the keys. If the secondary store is set then it will also set the values in the secondary store.
-     * @param {CacheableItem[]} items The items to set
-     * @returns {boolean} Whether the values were set
-     */
-    setMany(items: CacheableItem[]): Promise<boolean>;
-    /**
-     * Takes the value of the key and deletes the key. If the key does not exist then it will return undefined.
-     * @param {string} key The key to take the value of
-     * @returns {Promise<T | undefined>} The value of the key or undefined if the key does not exist
-     */
-    take<T>(key: string): Promise<T | undefined>;
-    /**
-     * Takes the values of the keys and deletes the keys. If the key does not exist then it will return undefined.
-     * @param {string[]} keys The keys to take the values of
-     * @returns {Promise<Array<T | undefined>>} The values of the keys or undefined if the key does not exist
-     */
-    takeMany<T>(keys: string[]): Promise<Array<T | undefined>>;
-    /**
-     * Checks if the key exists in the primary store. If it does not exist then it will check the secondary store.
-     * @param {string} key The key to check
-     * @returns {Promise<boolean>} Whether the key exists
-     */
-    has(key: string): Promise<boolean>;
-    /**
-     * Checks if the keys exist in the primary store. If it does not exist then it will check the secondary store.
-     * @param {string[]} keys The keys to check
-     * @returns {Promise<boolean[]>} Whether the keys exist
-     */
-    hasMany(keys: string[]): Promise<boolean[]>;
-    /**
-     * Deletes the key from the primary store. If the secondary store is set then it will also delete the key from the secondary store.
-     * @param {string} key The key to delete
-     * @returns {Promise<boolean>} Whether the key was deleted
-     */
-    delete(key: string): Promise<boolean>;
-    /**
-     * Deletes the keys from the primary store. If the secondary store is set then it will also delete the keys from the secondary store.
-     * @param {string[]} keys The keys to delete
-     * @returns {Promise<boolean>} Whether the keys were deleted
-     */
-    deleteMany(keys: string[]): Promise<boolean>;
-    /**
-     * Clears the primary store. If the secondary store is set then it will also clear the secondary store.
-     * @returns {Promise<void>}
-     */
-    clear(): Promise<void>;
-    /**
-     * Disconnects the primary store. If the secondary store is set then it will also disconnect the secondary store.
-     * @returns {Promise<void>}
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Wraps a function with caching
-     *
-     * [Learn more about wrapping functions](https://cacheable.org/docs/cacheable/#wrap--memoization-for-sync-and-async-functions).
-     * @param {Function} function_ The function to wrap
-     * @param {WrapOptions} [options] The options for the wrap function
-     * @returns {Function} The wrapped function
-     */
-    wrap<T, Arguments extends any[]>(function_: (...arguments_: Arguments) => T, options?: WrapFunctionOptions): (...arguments_: Arguments) => T;
-    /**
-     * Retrieves the value associated with the given key from the cache. If the key is not found,
-     * invokes the provided function to calculate the value, stores it in the cache, and then returns it.
-     *
-     * @param {GetOrSetKey} key - The key to retrieve or set in the cache. This can also be a function that returns a string key.
-     * If a function is provided, it will be called with the cache options to generate the key.
-     * @param {() => Promise<T>} function_ - The asynchronous function that computes the value to be cached if the key does not exist.
-     * @param {GetOrSetFunctionOptions} [options] - Optional settings for caching, such as the time to live (TTL) or whether to cache errors.
-     * @return {Promise<T | undefined>} - A promise that resolves to the cached or newly computed value, or undefined if an error occurs and caching is not configured for errors.
-     */
-    getOrSet<T>(key: GetOrSetKey, function_: () => Promise<T>, options?: GetOrSetFunctionOptions): Promise<T | undefined>;
-    /**
-     * Will hash an object asynchronously using the specified cryptographic algorithm.
-     * Use this for cryptographic algorithms (SHA-256, SHA-384, SHA-512).
-     * For non-cryptographic algorithms, use hashSync() for better performance.
-     * @param {any} object the object to hash
-     * @param {string} algorithm the hash algorithm to use. The default is 'SHA-256'
-     * @returns {Promise<string>} the hash of the object
-     */
-    hash(object: any, algorithm?: HashAlgorithm): Promise<string>;
-    /**
-     * Will hash an object synchronously using the specified non-cryptographic algorithm.
-     * Use this for non-cryptographic algorithms (DJB2, FNV1, MURMER, CRC32).
-     * For cryptographic algorithms, use hash() instead.
-     * @param {any} object the object to hash
-     * @param {string} algorithm the hash algorithm to use. The default is 'djb2'
-     * @returns {string} the hash of the object
-     */
-    hashSync(object: any, algorithm?: HashAlgorithm): string;
-    private setManyKeyv;
-    /**
-     * Processes a single key from secondary store for getRaw operation
-     * @param primary - the primary store to use
-     * @param secondary - the secondary store to use
-     * @param key - The key to retrieve from secondary store
-     * @returns Promise containing the result and TTL information
-     */
-    private processSecondaryForGetRaw;
-    /**
-     * Processes a single key from secondary store for getRaw operation in non-blocking mode
-     * Non-blocking mode means we don't wait for secondary operations that update primary store
-     * @param primary - the primary store to use
-     * @param secondary - the secondary store to use
-     * @param key - The key to retrieve from secondary store
-     * @returns Promise containing the result and TTL information
-     */
-    private processSecondaryForGetRawNonBlocking;
-    /**
-     * Processes missing keys from secondary store for getManyRaw operation
-     * @param primary - the primary store to use
-     * @param secondary - the secondary store to use
-     * @param keys - The original array of keys requested
-     * @param result - The result array from primary store (will be modified)
-     * @returns Promise<void>
-     */
-    private processSecondaryForGetManyRaw;
-    /**
-     * Processes missing keys from secondary store for getManyRaw operation in non-blocking mode
-     * Non-blocking mode means we don't wait for secondary operations that update primary store
-     * @param secondary - the secondary store to use
-     * @param keys - The original array of keys requested
-     * @param result - The result array from primary store (will be modified)
-     * @returns Promise<void>
-     */
-    private processSecondaryForGetManyRawNonBlocking;
-    private setTtl;
-}
-
-export { Cacheable, CacheableEvents, CacheableHooks, type CacheableOptions, CacheableSync, CacheableSyncEvents, type CacheableSyncItem, type CacheableSyncOptions };