node_modules/cacheable/dist/index.d.cts - devtools/devtools-frontend - Git at Google

 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 };
	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 };