@gomomento/sdk-core 1.115.0 → 1.116.0

package/dist/src/internal/clients/cache/AbstractCacheClient.d.ts

@@ -1,7 +1,7 @@
 import { CreateCache, DeleteCache, ListCaches, CacheFlush, CacheGet, CacheSet, CacheDelete, CacheIncrement, IncrementOptions, CacheSetIfNotExists, SetIfNotExistsOptions, SetIfAbsentOptions, SetIfPresentOptions, SetIfEqualOptions, SetIfNotEqualOptions, SetIfPresentAndNotEqualOptions, SetIfAbsentOrEqualOptions, SetIfPresentAndHashEqualOptions, SetIfPresentAndHashNotEqualOptions, SetIfAbsentOrHashEqualOptions, SetIfAbsentOrHashNotEqualOptions, CacheSetFetch, CacheSetAddElement, CacheSetAddElements, CacheSetContainsElement, CacheSetContainsElements, CacheSetRemoveElement, CacheSetRemoveElements, CacheListFetch, CacheListLength, CacheListPushFront, CacheListPushBack, CacheListConcatenateBack, CacheListConcatenateFront, CacheListPopBack, CacheListPopFront, CacheListRemoveValue, CacheListRetain, CacheDictionarySetField, CacheDictionarySetFields, CacheDictionaryGetField, CacheDictionaryGetFields, CacheDictionaryIncrement, CacheDictionaryFetch, CacheDictionaryRemoveField, CacheDictionaryRemoveFields, CacheDictionaryLength, CacheSortedSetFetch, CacheSortedSetPutElement, CacheSortedSetPutElements, CacheSortedSetGetRank, CacheSortedSetGetScore, CacheSortedSetGetScores, CacheSortedSetIncrementScore, CacheSortedSetRemoveElement, CacheSortedSetRemoveElements, CacheSortedSetLength, CacheSortedSetLengthByScore, CacheSortedSetUnionStore, CacheItemGetTtl, CacheItemGetType, CacheKeyExists, CacheKeysExist, CacheUpdateTtl, CacheIncreaseTtl, CacheDecreaseTtl, CacheGetBatch, CacheSetBatch, CacheSetIfAbsent, CacheSetIfPresent, CacheSetIfEqual, CacheSetIfNotEqual, CacheSetIfPresentAndNotEqual, CacheSetIfAbsentOrEqual, CacheSetSample, CacheSetPop, CacheSetLength, CacheGetWithHash, CacheSetWithHash, CacheSetIfPresentAndHashEqual, CacheSetIfPresentAndHashNotEqual, CacheSetIfAbsentOrHashEqual, CacheSetIfAbsentOrHashNotEqual } from '../../../index';
 import { ListFetchCallOptions, ListRetainCallOptions, SetBatchItem, SortedSetSource } from '../../../utils';
-import { ICacheClient, SetOptions, SetAddElementOptions, SetAddElementsOptions, ListPushFrontOptions, ListPushBackOptions, ListConcatenateBackOptions, ListConcatenateFrontOptions, DictionarySetFieldOptions, DictionarySetFieldsOptions, DictionaryIncrementOptions, SortedSetFetchByRankOptions, SortedSetPutElementOptions, SortedSetPutElementsOptions, SortedSetFetchByScoreOptions, SortedSetGetRankOptions, SortedSetIncrementOptions, SortedSetLengthByScoreOptions, SortedSetUnionStoreOptions, SetBatchOptions, GetOptions, GetBatchOptions, GetWithHashOptions, SetWithHashOptions } from '../../../clients/ICacheClient';
-import { IControlClient } from './IControlClient';
+import { ICacheClient, SetOptions, SetAddElementOptions, SetAddElementsOptions, ListPushFrontOptions, ListPushBackOptions, ListConcatenateBackOptions, ListConcatenateFrontOptions, DictionarySetFieldOptions, DictionarySetFieldsOptions, DictionaryIncrementOptions, SortedSetFetchByRankOptions, SortedSetPutElementOptions, SortedSetPutElementsOptions, SortedSetFetchByScoreOptions, SortedSetGetRankOptions, SortedSetIncrementOptions, SortedSetLengthByScoreOptions, SortedSetUnionStoreOptions, SetBatchOptions, GetOptions, GetBatchOptions, GetWithHashOptions, SetWithHashOptions, SetFetchOptions, DeleteOptions, ListLengthOptions, ListPopBackOptions, ListPopFrontOptions, ListRemoveValueOptions, SetContainsElementsOptions, SetRemoveElementsOptions, SetSampleOptions, SetPopOptions, SetLengthOptions, DictionaryFetchOptions, DictionaryGetFieldOptions, DictionaryRemoveFieldOptions, DictionaryLengthOptions, SortedSetGetScoreOptions, SortedSetRemoveElementOptions, SortedSetLengthOptions, ItemGetTypeOptions, ItemGetTtlOptions, KeyExistsOptions, UpdateTtlOptions, IncreaseTtlOptions, DecreaseTtlOptions } from '../../../clients/ICacheClient';
+import { ControlCallOptions, IControlClient } from './IControlClient';
 import { IDataClient } from './IDataClient';
 import { IPingClient } from './IPingClient';
 import { IMomentoCache } from '../../../clients/IMomentoCache';
@@ -25,7 +25,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * {@link CreateCache.AlreadyExists} if the cache already exists.
      * {@link CreateCache.Error} on failure.
      */
-    createCache(cacheName: string): Promise<CreateCache.Response>;
+    createCache(cacheName: string, options?: ControlCallOptions): Promise<CreateCache.Response>;
     /**
      * Deletes a cache and all items stored in it.
      *
@@ -34,7 +34,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * {@link DeleteCache.Success} on success.
      * {@link DeleteCache.Error} on failure.
      */
-    deleteCache(cacheName: string): Promise<DeleteCache.Response>;
+    deleteCache(cacheName: string, options?: ControlCallOptions): Promise<DeleteCache.Response>;
     /**
      * Lists all caches.
      *
@@ -42,7 +42,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * {@link ListCaches.Success} containing the list on success.
      * {@link ListCaches.Error} on failure.
      */
-    listCaches(): Promise<ListCaches.Response>;
+    listCaches(options?: ControlCallOptions): Promise<ListCaches.Response>;
     /**
      * Gets the value stored for the given key.
      *
@@ -51,6 +51,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {GetOptions} [options]
      * @param {decompress} [options.decompress=false] - Whether to decompress the value. Overrides the client-wide
      * automatic decompression setting.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheGet.Response>} -
      * {@link CacheGet.Hit} containing the value if one is found.
      * {@link CacheGet.Miss} if the key does not exist.
@@ -65,6 +66,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {GetOptions} [options]
      * @param {decompress} [options.decompress=false] - Whether to decompress the value. Overrides the client-wide
      * automatic decompression setting.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheGet.Response>} -
      * {@link CacheGetWithHash.Hit} containing the value and hash if one is found.
      * {@link CacheGetWithHash.Miss} if the key does not exist.
@@ -80,6 +82,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string | Uint8Array} value - The value to be stored.
      * @param {SetOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * Uses the client's default TTL if this is not supplied.
      * @param {boolean} [options.compress=false] - Whether to compress the value. Defaults to false.
      * @returns {Promise<CacheSet.Response>} -
@@ -94,10 +97,11 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string} cacheName - The cache to store the value in.
      * @param {string | Uint8Array} key - The key to set.
      * @param {string | Uint8Array} value - The value to be stored.
-     * @param {SetOptions} [options]
+     * @param {SetWithHashOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
      * Uses the client's default TTL if this is not supplied.
      * @param {boolean} [options.compress=false] - Whether to compress the value. Defaults to false.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSet.Response>} -
      * {@link CacheSetWithHash.Stored} on success containing the hash of the value stored.
      * {@link CacheSetWithHash.NotStored} on not storing the new value.
@@ -110,11 +114,13 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      *
      * @param {string} cacheName - The cache to delete from.
      * @param {string | Uint8Array} key - The key to delete.
+     * @param {DeleteOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheDelete.Response>} -
      * {@link CacheDelete.Success} on success.
      * {@link CacheDelete.Error} on failure.
      */
-    delete(cacheName: string, key: string | Uint8Array): Promise<CacheDelete.Response>;
+    delete(cacheName: string, key: string | Uint8Array, options?: DeleteOptions): Promise<CacheDelete.Response>;
     /**
      * Gets the value stored for the given keys.
      *
@@ -123,6 +129,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {GetBatchOptions} [options]
      * @param {decompress} [options.decompress=false] - Whether to decompress the value. Overrides the client-wide
      * automatic decompression setting.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheGetBatch.Response>} -
      * {@link CacheGetBatch.Success} containing the values if they were found.
      * {@link CacheGetBatch.Error} on failure.
@@ -138,6 +145,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {number} [options.ttl] - The time to live for the items in the cache.
      * Uses the client's default TTL if this is not supplied.
      * @param {boolean} [options.compress=false] - Whether to compress the value. Defaults to false.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetBatch.Response>} -
      * {@link CacheSetBatch.Success} on success.
      * {@link CacheSetBatch.Error} on failure.
@@ -156,6 +164,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the list's TTL using the client's default if this is not
      * supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheListConcatenateBack.Response>} -
      * {@link CacheListConcatenateBack.Success} on success.
      * {@link CacheListConcatenateBack.Error} on failure.
@@ -174,6 +183,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the list's TTL using the client's default if this is not
      * supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheListConcatenateFront.Response>} -
      * {@link CacheListConcatenateFront.Success} on success.
      * {@link CacheListConcatenateFront.Error} on failure.
@@ -187,6 +197,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {ListFetchCallOptions} [options]
      * @param {number} [options.startIndex] - Start inclusive index for fetch operation.
      * @param {number} [options.endIndex] - End exclusive index for fetch operation.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheListFetch.Response>} -
      * {@link CacheListFetch.Hit} containing the list elements if the list exists.
      * {@link CacheListFetch.Miss} if the list does not exist.
@@ -198,34 +209,40 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      *
      * @param {string} cacheName - The cache containing the list.
      * @param {string} listName - The list to get the length of.
+     * @param {ListLengthOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheListLength.Response>} -
      * {@link CacheListLength.Hit} containing the length if the list exists.
      * {@link CacheListLength.Miss} if the list does not exist.
      * {@link CacheListLength.Error} on failure.
      */
-    listLength(cacheName: string, listName: string): Promise<CacheListLength.Response>;
+    listLength(cacheName: string, listName: string, options?: ListLengthOptions): Promise<CacheListLength.Response>;
     /**
      * Gets and removes the last value from the given list.
      *
      * @param {string} cacheName - The cache containing the list.
      * @param {string} listName - The list to pop.
+     * @param {ListPopBackOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheListPopBack.Response>} -
      * {@link CacheListPopBack.Hit} containing the element if the list exists.
      * {@link CacheListPopBack.Miss} if the list does not exist.
      * {@link CacheListPopBack.Error} on failure.
      */
-    listPopBack(cacheName: string, listName: string): Promise<CacheListPopBack.Response>;
+    listPopBack(cacheName: string, listName: string, options?: ListPopBackOptions): Promise<CacheListPopBack.Response>;
     /**
      * Gets and removes the first value from the given list.
      *
      * @param {string} cacheName - The cache containing the list.
      * @param {string} listName - The list to pop.
+     * @param {ListPopFrontOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheListPopFront.Response>} -
      * {@link CacheListPopFront.Hit} containing the element if the list exists.
      * {@link CacheListPopFront.Miss} if the list does not exist.
      * {@link CacheListPopFront.Error} on failure.
      */
-    listPopFront(cacheName: string, listName: string): Promise<CacheListPopFront.Response>;
+    listPopFront(cacheName: string, listName: string, options?: ListPopFrontOptions): Promise<CacheListPopFront.Response>;
     /**
      * Adds an element to the back of the given list. Creates the list if
      * it does not already exist.
@@ -239,6 +256,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the list's TTL using the client's default if this is not
      * supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheListPushBack.Response>} -
      * {@link CacheListPushBack.Success} containing the list's new length on
      * success.
@@ -258,6 +276,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the list's TTL using the client's default if this is not
      * supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheListPushFront.Response>} -
      * {@link CacheListPushFront.Success} containing the list's new length on
      * success.
@@ -270,13 +289,15 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string} cacheName - The cache containing the list.
      * @param {string} listName - The list to remove from.
      * @param {string | Uint8Array} value - The value to remove.
+     * @param {ListRemoveValueOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheListRemoveValue.Response>} -
      * {@link CacheListRemoveValue.Success} on success. Removing an element that
      * does not occur in the list or removing from a non-existent list counts as a
      * success.
      * {@link CacheListRemoveValue.Error} on failure.
      */
-    listRemoveValue(cacheName: string, listName: string, value: string | Uint8Array): Promise<CacheListRemoveValue.Response>;
+    listRemoveValue(cacheName: string, listName: string, value: string | Uint8Array, options?: ListRemoveValueOptions): Promise<CacheListRemoveValue.Response>;
     /**
      * Retains slice of elements of a given list, deletes the rest of the list
      * that isn't being retained. Returns a Success or Error.
@@ -291,6 +312,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the list's TTL using the client's default if this is not
      * supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheListRetain.Response>} -
      * {@link CacheListRetain.Success} on success.
      * {@link CacheListRetain.Error} on failure.
@@ -301,12 +323,14 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      *
      * @param {string} cacheName - The cache containing the set.
      * @param {string} setName - The set to fetch.
+     * @param {SetFetchOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetFetch.Response>} -
      * {@link CacheSetFetch.Hit} containing the set elements if the set exists.
      * {@link CacheSetFetch.Miss} if the set does not exist.
      * {@link CacheSetFetch.Error} on failure.
      */
-    setFetch(cacheName: string, setName: string): Promise<CacheSetFetch.Response>;
+    setFetch(cacheName: string, setName: string, options?: SetFetchOptions): Promise<CacheSetFetch.Response>;
     /**
      * Adds an element to the given set. Creates the set if it does not already
      * exist.
@@ -321,6 +345,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {SetAddElementOptions} options
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the set's TTL using the client's default if this is not supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetAddElement.Response>} -
      * {@link CacheSetAddElement.Success} on success.
      * {@link CacheSetAddElement.Error} on failure.
@@ -340,6 +365,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {SetAddElementsOptions} options
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the set's TTL using the client's default if this is not supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetAddElements.Response>} -
      * {@link CacheSetAddElements.Success} on success.
      * {@link CacheSetAddElements.Error} on failure.
@@ -350,49 +376,57 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param cacheName - The cache containing the set.
      * @param setName - The set to check.
      * @param element - The element to check for.
+     * @param {SetContainsElementsOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetContainsElement.Response>} -
      * {@link CacheSetContainsElement.Hit} if the set exists and contains the element.
      * {@link CacheSetContainsElement.Miss} if the set does not contain the element.
      * {@link CacheSetContainsElement.Error} on failure.
      */
-    setContainsElement(cacheName: string, setName: string, element: string | Uint8Array): Promise<CacheSetContainsElement.Response>;
+    setContainsElement(cacheName: string, setName: string, element: string | Uint8Array, options?: SetContainsElementsOptions): Promise<CacheSetContainsElement.Response>;
     /**
      * Tests if the given set contains the given elements.
      * @param cacheName - The cache containing the set.
      * @param setName - The set to check.
      * @param elements - The elements to check for.
+     * @param {SetContainsElementsOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetContainsElements.Response>} -
      * {@link CacheSetContainsElements.Hit} containing the elements to their presence in the cache.
      * {@link CacheSetContainsElements.Miss} if the set does not contain the elements.
      * {@link CacheSetContainsElements.Error} on failure.
      */
-    setContainsElements(cacheName: string, setName: string, elements: string[] | Uint8Array[]): Promise<CacheSetContainsElements.Response>;
+    setContainsElements(cacheName: string, setName: string, elements: string[] | Uint8Array[], options?: SetContainsElementsOptions): Promise<CacheSetContainsElements.Response>;
     /**
      * Removes an element from the given set.
      *
      * @param {string} cacheName - The cache containing the set.
      * @param {string} setName - The set to remove from.
      * @param {string | Uint8Array} element - The element to remove.
+     * @param {SetRemoveElementsOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetRemoveElement.Response>} -
      * {@link CacheSetRemoveElement.Success} on success. Removing an element that
      * does not occur in the set or removing from a non-existent set counts as a
      * success.
      * {@link CacheSetRemoveElement.Error} on failure.
      */
-    setRemoveElement(cacheName: string, setName: string, element: string | Uint8Array): Promise<CacheSetRemoveElement.Response>;
+    setRemoveElement(cacheName: string, setName: string, element: string | Uint8Array, options?: SetRemoveElementsOptions): Promise<CacheSetRemoveElement.Response>;
     /**
      * Removes multiple elements from the given set.
      *
      * @param {string} cacheName - The cache containing the set.
      * @param {string} setName - The set to remove from.
      * @param {string[] | Uint8Array[]} elements - The elements to remove.
+     * @param {SetRemoveElementsOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetRemoveElements.Response>} -
      * {@link CacheSetRemoveElements.Success} on success. Removing elements that
      * do not occur in the set or removing from a non-existent set counts as a
      * success.
      * {@link CacheSetRemoveElements.Error} on failure.
      */
-    setRemoveElements(cacheName: string, setName: string, elements: string[] | Uint8Array[]): Promise<CacheSetRemoveElements.Response>;
+    setRemoveElements(cacheName: string, setName: string, elements: string[] | Uint8Array[], options?: SetRemoveElementsOptions): Promise<CacheSetRemoveElements.Response>;
     /**
      * Fetch a random sample of elements from the set.
      * Returns a different random sample for each call.
@@ -401,36 +435,42 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string} setName - The set to remove from.
      * @param {number} limit - The maximum number of elements to return.
      * If the set contains fewer than 'limit' elements, the entire set will be returned.
+     * @param {SetSampleOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetSample.Response>} -
      * {@link CacheSetSample.Hit} containing the set elements if the set exists.
      * {@link CacheSetSample.Miss} if the set does not exist.
      * {@link CacheSetSample.Error} on failure.
      */
-    setSample(cacheName: string, setName: string, limit: number): Promise<CacheSetSample.Response>;
+    setSample(cacheName: string, setName: string, limit: number, options?: SetSampleOptions): Promise<CacheSetSample.Response>;
     /**
      * Pops a random sample of elements from the set.
      *
      * @param {string} cacheName - The cache containing the set.
      * @param {string} setName - The set to remove from.
      * @param {number} count - The maximum number of elements to return.
+     * @param {SetPopOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * If the set contains fewer than 'limit' elements, the entire set will be returned.
      * @returns {Promise<CacheSetPop.Response>} -
      * {@link CacheSetPop.Hit} containing the set elements if the set exists.
      * {@link CacheSetPop.Miss} if the set does not exist.
      * {@link CacheSetPop.Error} on failure.
      */
-    setPop(cacheName: string, setName: string, count: number): Promise<CacheSetPop.Response>;
+    setPop(cacheName: string, setName: string, count: number, options?: SetPopOptions): Promise<CacheSetPop.Response>;
     /**
      * Get the number of elements in the set.
      *
      * @param {string} cacheName - The cache containing the set.
      * @param {string} setName - The set to remove from.
+     * @param {SetLengthOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetLength.Response>} -
      * {@link CacheSetLength.Hit} containing the set elements if the set exists.
      * {@link CacheSetLength.Miss} if the set does not exist.
      * {@link CacheSetLength.Error} on failure.
      */
-    setLength(cacheName: string, setName: string): Promise<CacheSetLength.Response>;
+    setLength(cacheName: string, setName: string, options?: SetLengthOptions): Promise<CacheSetLength.Response>;
     /**
      * Associates the given key with the given value if key is not already present in the cache.
      *
@@ -440,6 +480,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string | Uint8Array} field - The value to be stored.
      * @param {SetIfNotExistsOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * Uses the client's default TTL if this is not supplied.
      * @returns {Promise<CacheSetIfNotExists.Response>} -
      * {@link CacheSetIfNotExists.Stored} on storing the new value.
@@ -455,6 +496,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string | Uint8Array} field - The value to be stored.
      * @param {SetIfAbsentOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * Uses the client's default TTL if this is not supplied.
      * @param {boolean} [options.compress=false] - Whether to compress the value. Defaults to false.
      * @returns {Promise<CacheSetIfAbsent.Response>} -
@@ -471,6 +513,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string | Uint8Array} field - The value to be stored.
      * @param {SetIfPresentOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * Uses the client's default TTL if this is not supplied.
      * @returns {Promise<CacheSetIfPresent.Response>} -
      * {@link CacheSetIfPresent.Stored} on storing the new value.
@@ -488,6 +531,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string | Uint8Array} equal - The value to compare to the cached value.
      * @param {SetIfEqualOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * Uses the client's default TTL if this is not supplied.
      * @returns {Promise<CacheSetIfEqual.Response>} -
      * {@link CacheSetIfEqual.Stored} on storing the new value.
@@ -506,6 +550,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {SetIfNotEqualOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
      * Uses the client's default TTL if this is not supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetIfNotEqual.Response>} -
      * {@link CacheSetIfNotEqual.Stored} on storing the new value.
      * {@link CacheSetIfNotEqual.NotStored} on not storing the new value.
@@ -523,6 +568,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {SetIfAbsentOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
      * Uses the client's default TTL if this is not supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetIfPresentAndNotEqual.Response>} -
      * {@link CacheSetIfPresentAndNotEqual.Stored} on storing the new value.
      * {@link CacheSetIfPresentAndNotEqual.NotStored} on not storing the new value.
@@ -540,6 +586,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {SetIfAbsentOrEqualOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
      * Uses the client's default TTL if this is not supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetIfAbsentOrEqual.Response>} -
      * {@link CacheSetIfAbsentOrEqual.Stored} on storing the new value.
      * {@link CacheSetIfAbsentOrEqual.NotStored} on not storing the new value.
@@ -556,6 +603,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {Uint8Array} hashEqual - The hash to compare to the cached hash.
      * @param {SetIfPresentAndHashEqualOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * Uses the client's default TTL if this is not supplied.
      * @returns {Promise<CacheSetIfPresentAndHashEqual.Response>} -
      * {@link CacheSetIfPresentAndHashEqual.Stored} on storing the new value.
@@ -574,6 +622,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {SetIfPresentAndHashNotEqualOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
      * Uses the client's default TTL if this is not supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetIfPresentAndHashNotEqual.Response>} -
      * {@link CacheSetIfPresentAndHashNotEqual.Stored} on storing the new value.
      * {@link CacheSetIfPresentAndHashNotEqual.NotStored} on not storing the new value.
@@ -591,6 +640,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {setIfAbsentOrHashEqualOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
      * Uses the client's default TTL if this is not supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSetIfAbsentOrHashEqual.Response>} -
      * {@link CacheSetIfAbsentOrHashEqual.Stored} on storing the new value.
      * {@link CacheSetIfAbsentOrHashEqual.NotStored} on not storing the new value.
@@ -607,6 +657,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string | Uint8Array} hashNotEqual - The value to compare to the cached value.
      * @param {SetIfAbsentOrHashNotEqualOptions} [options]
      * @param {number} [options.ttl] - The time to live for the item in the cache.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * Uses the client's default TTL if this is not supplied.
      * @returns {Promise<CacheSetIfAbsentOrHashNotEqual.Response>} -
      * {@link CacheSetIfAbsentOrHashNotEqual.Stored} on storing the new value.
@@ -622,19 +673,21 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * {@link CacheFlush.Success} on success.
      * {@link CacheFlush.Error} on failure.
      */
-    flushCache(cacheName: string): Promise<CacheFlush.Response>;
+    flushCache(cacheName: string, options?: ControlCallOptions): Promise<CacheFlush.Response>;
     /**
      * Fetches all elements of the given dictionary.
      *
      * @param {string} cacheName - The cache to perform the lookup in.
      * @param {string} dictionaryName - The dictionary to fetch.
+     * @param {DictionaryFetchOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheDictionaryFetch.Response>} -
      * {@link CacheDictionaryFetch.Hit} containing the dictionary elements if the
      * dictionary exists.
      * {@link CacheDictionaryFetch.Miss} if the dictionary does not exist.
      * {@link CacheDictionaryFetch.Error} on failure.
      */
-    dictionaryFetch(cacheName: string, dictionaryName: string): Promise<CacheDictionaryFetch.Response>;
+    dictionaryFetch(cacheName: string, dictionaryName: string, options?: DictionaryFetchOptions): Promise<CacheDictionaryFetch.Response>;
     /**
      * Adds an integer quantity to a field value.
      *
@@ -647,6 +700,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * negative, or zero. Defaults to 1.
      * @param {IncrementOptions} options
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheIncrement>} -
      * {@link CacheIncrement.Success} containing the incremented value
      * on success.
@@ -667,6 +721,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the dictionary's TTL using the client's default if this is not
      * supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheDictionarySetField.Response>} -
      * {@link CacheDictionarySetField.Success} on success.
      * {@link CacheDictionarySetField.Error} on failure.
@@ -684,6 +739,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the dictionary's TTL using the client's default if this is not
      * supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheDictionarySetFields.Response>} -
      * {@link CacheDictionarySetFields.Success} on success.
      * {@link CacheDictionarySetFields.Error} on failure.
@@ -695,26 +751,30 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string} cacheName - The cache containing the dictionary.
      * @param {string} dictionaryName - The dictionary to look up.
      * @param {string | Uint8Array} field - The field to look up.
+     * @param {DictionaryGetFieldOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheDictionaryGetField.Response>} -
      * {@link CacheDictionaryGetField.Hit} containing the dictionary element if
      * one is found.
      * {@link CacheDictionaryGetField.Miss} if the dictionary does not exist.
      * {@link CacheDictionaryGetField.Error} on failure.
      */
-    dictionaryGetField(cacheName: string, dictionaryName: string, field: string | Uint8Array): Promise<CacheDictionaryGetField.Response>;
+    dictionaryGetField(cacheName: string, dictionaryName: string, field: string | Uint8Array, options?: DictionaryGetFieldOptions): Promise<CacheDictionaryGetField.Response>;
     /**
      * Gets multiple values from the given dictionary.
      *
      * @param {string} cacheName - The cache containing the dictionary.
      * @param {string} dictionaryName - The dictionary to look up.
      * @param {string[] | Uint8Array[]} fields - The fields to look up.
+     * @param {DictionaryGetFieldOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheDictionaryGetFields.Response>} -
      * {@link CacheDictionaryGetFields.Hit} containing the dictionary elements if
      * the dictionary exists.
      * {@link CacheDictionaryGetFields.Miss} if the dictionary does not exist.
      * {@link CacheDictionaryGetFields.Error} on failure.
      */
-    dictionaryGetFields(cacheName: string, dictionaryName: string, fields: string[] | Uint8Array[]): Promise<CacheDictionaryGetFields.Response>;
+    dictionaryGetFields(cacheName: string, dictionaryName: string, fields: string[] | Uint8Array[], options?: DictionaryGetFieldOptions): Promise<CacheDictionaryGetFields.Response>;
     /**
      * Removes an element from the given dictionary.
      *
@@ -724,11 +784,13 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string} cacheName - The cache containing the dictionary.
      * @param {string} dictionaryName - The dictionary to remove from.
      * @param {string | Uint8Array} field - The field to remove.
+     * @param {DictionaryRemoveFieldOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheDictionaryRemoveField.Response>} -
      * {@link CacheDictionaryRemoveField.Success} on success.
      * {@link CacheDictionaryRemoveField.Error} on failure.
      */
-    dictionaryRemoveField(cacheName: string, dictionaryName: string, field: string | Uint8Array): Promise<CacheDictionaryRemoveField.Response>;
+    dictionaryRemoveField(cacheName: string, dictionaryName: string, field: string | Uint8Array, options?: DictionaryRemoveFieldOptions): Promise<CacheDictionaryRemoveField.Response>;
     /**
      * Removes multiple fields from the given dictionary.
      *
@@ -738,11 +800,13 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string} cacheName - The cache containing the dictionary.
      * @param {string} dictionaryName - The dictionary to remove from.
      * @param {string[] | Uint8Array[]} fields - The fields to remove.
+     * @param {DictionaryRemoveFieldOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheDictionaryRemoveFields.Response>} -
      * {@link CacheDictionaryRemoveFields.Success} on success.
      * {@link CacheDictionaryRemoveFields.Error} on failure.
      */
-    dictionaryRemoveFields(cacheName: string, dictionaryName: string, fields: string[] | Uint8Array[]): Promise<CacheDictionaryRemoveFields.Response>;
+    dictionaryRemoveFields(cacheName: string, dictionaryName: string, fields: string[] | Uint8Array[], options?: DictionaryRemoveFieldOptions): Promise<CacheDictionaryRemoveFields.Response>;
     /**
      * Adds an integer quantity to a dictionary value.
      *
@@ -758,6 +822,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the dictionary's TTL using the client's default if this is not
      * supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheDictionaryIncrement.Response>} -
      * {@link CacheDictionaryIncrement.Success} containing the incremented value
      * on success.
@@ -771,12 +836,14 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      *
      * @param {string} cacheName - The cache containing the dictionary.
      * @param {string} dictionaryName - The dictionary to get the length of.
+     * @param {DictionaryLengthOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheDictionaryLength.Response>} -
      * {@link CacheDictionaryLength.Hit} containing the length if the dictionary exists.
      * {@link CacheDictionaryLength.Miss} if the dictionary does not exist.
      * {@link CacheDictionaryLength.Error} on failure.
      */
-    dictionaryLength(cacheName: string, dictionaryName: string): Promise<CacheDictionaryLength.Response>;
+    dictionaryLength(cacheName: string, dictionaryName: string, options?: DictionaryLengthOptions): Promise<CacheDictionaryLength.Response>;
     /**
      * Adds an element to the given sorted set. If the element already exists, its
      * score is updated. Creates the sorted set if it does not exist.
@@ -789,6 +856,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the sorted set's TTL using the client's default if this is not
      * supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetPutElement.Response>} -
      * {@link CacheSortedSetPutElement.Success} on success.
      * {@link CacheSortedSetPutElement.Error} on failure.
@@ -806,6 +874,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the sorted set's TTL using the client's default if this is not
      * supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetPutElements.Response>} -
      * {@link CacheSortedSetPutElements.Success} on success.
      * {@link CacheSortedSetPutElements.Error} on failure.
@@ -826,6 +895,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * Defaults to null, which fetches up until and including the last element.
      * @param {SortedSetOrder} [options.order] - The order to fetch the elements in.
      * Defaults to ascending.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetFetch.Response>}
      * {@link CacheSortedSetFetch.Hit} containing the requested elements when found.
      * {@link CacheSortedSetFetch.Miss} when the sorted set does not exist.
@@ -850,6 +920,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * to skip before returning the first element.
      * @param {number} [options.count] - The maximum number of elements to return.
      * Defaults to undefined, which returns all elements.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetFetch.Response>} -
      * {@link CacheSortedSetFetch.Hit} containing the requested elements when found.
      * {@link CacheSortedSetFetch.Miss} when the sorted set does not exist.
@@ -865,6 +936,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {SortedSetGetRankOptions} options
      * @param {SortedSetOrder} [options.order] - The order in which sorted set will be sorted to determine the rank.
      * Defaults to ascending.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetGetRank.Response>}
      * {@link CacheSortedSetGetRank.Hit} containing the rank of the requested elements when found.
      * {@link CacheSortedSetGetRank.Miss} when the element does not exist.
@@ -877,24 +949,28 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string} cacheName - The cache containing the sorted set.
      * @param {string} sortedSetName - The sorted set to fetch from.
      * @param {string | Uint8Array} value - The value of the element whose score we are retrieving.
+     * @param {SortedSetGetScoreOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetGetScore.Response>}
      * {@link CacheSortedSetGetScore.Hit} containing the score of the requested element when found.
      * {@link CacheSortedSetGetScore.Miss} when the element or collection does not exist.
      * {@link CacheSortedSetGetScore.Error} on failure.
      */
-    sortedSetGetScore(cacheName: string, sortedSetName: string, value: string | Uint8Array): Promise<CacheSortedSetGetScore.Response>;
+    sortedSetGetScore(cacheName: string, sortedSetName: string, value: string | Uint8Array, options?: SortedSetGetScoreOptions): Promise<CacheSortedSetGetScore.Response>;
     /**
      * Look up the scores of multiple elements in the sorted set, by the value of the elements.
      *
      * @param {string} cacheName - The cache containing the sorted set.
      * @param {string} sortedSetName - The sorted set to fetch from.
      * @param {string[] | Uint8Array[]} values - The values of the elements whose scores we are retrieving.
+     * @param {SortedSetGetScoreOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetGetScores.Response>}
      * {@link CacheSortedSetGetScores.Hit} containing the scores of the requested elements when found.
      * {@link CacheSortedSetGetScores.Miss} when the element or collection does not exist.
      * {@link CacheSortedSetGetScores.Error} on failure.
      */
-    sortedSetGetScores(cacheName: string, sortedSetName: string, values: string[] | Uint8Array[]): Promise<CacheSortedSetGetScores.Response>;
+    sortedSetGetScores(cacheName: string, sortedSetName: string, values: string[] | Uint8Array[], options?: SortedSetGetScoreOptions): Promise<CacheSortedSetGetScores.Response>;
     /**
      * Increment the score of an element in the sorted set.
      *
@@ -907,6 +983,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.
      * Refreshes the sorted set's TTL using the client's default if this is not
      * supplied.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetIncrementScore.Response>} -
      * {@link CacheSortedSetIncrementScore.Success} containing the incremented score
      * on success.
@@ -920,31 +997,37 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {string} cacheName - The cache containing the sorted set.
      * @param {string} sortedSetName - The sorted set to remove from.
      * @param {string | Uint8Array} value - The value of the element to remove from the set.
+     * @param {SortedSetRemoveElementOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetRemoveElement.Response>}
      * {@link CacheSortedSetRemoveElement.Success} if the element was successfully removed
      * {@link CacheSortedSetIncrementScore.Error} on failure
      */
-    sortedSetRemoveElement(cacheName: string, sortedSetName: string, value: string | Uint8Array): Promise<CacheSortedSetRemoveElement.Response>;
+    sortedSetRemoveElement(cacheName: string, sortedSetName: string, value: string | Uint8Array, options?: SortedSetRemoveElementOptions): Promise<CacheSortedSetRemoveElement.Response>;
     /**
      * Remove multiple elements from the sorted set
      * @param {string} cacheName - The cache containing the sorted set.
      * @param {string} sortedSetName - The sorted set to remove from.
      * @param {string | Uint8Array} values - The values of the elements to remove from the set.
+     * @param {SortedSetRemoveElementOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetRemoveElement.Response>}
      * {@link CacheSortedSetRemoveElement.Success} if the elements were successfully removed
      * {@link CacheSortedSetIncrementScore.Error} on failure
      */
-    sortedSetRemoveElements(cacheName: string, sortedSetName: string, values: string[] | Uint8Array[]): Promise<CacheSortedSetRemoveElements.Response>;
+    sortedSetRemoveElements(cacheName: string, sortedSetName: string, values: string[] | Uint8Array[], options?: SortedSetRemoveElementOptions): Promise<CacheSortedSetRemoveElements.Response>;
     /**
      * Fetch length (number of items) of sorted set
      * @param {string} cacheName - The cache containing the sorted set.
      * @param {string} sortedSetName - The sorted set name.
+     * @param {SortedSetLengthOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetLength.Response>}
      * {@link CacheSortedSetLength.Hit} containing the length if the sorted set exists.
      * {@link CacheSortedSetLength.Miss} if the sorted set does not exist.
      * {@link CacheSortedSetLength.Error} on failure.
      */
-    sortedSetLength(cacheName: string, sortedSetName: string): Promise<CacheSortedSetLength.Response>;
+    sortedSetLength(cacheName: string, sortedSetName: string, options?: SortedSetLengthOptions): Promise<CacheSortedSetLength.Response>;
     /**
      * Fetch length (number of items) of sorted set within the provided score range
      * @param {string} cacheName - The cache containing the sorted set.
@@ -952,6 +1035,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {SortedSetLengthByScoreOptions} options - Optional parameter for specifying the score range to search in.
      * @param {number} [options.minScore] - The lower bound on the score range to search in.
      * @param {number} [options.maxScore] - The upper bound on the score range to search in.
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetLengthByScore.Response>}
      * {@link CacheSortedSetLengthByScore.Hit} containing the length if the sorted set exists.
      * {@link CacheSortedSetLengthByScore.Miss} if the sorted set does not exist.
@@ -967,6 +1051,7 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * @param {SortedSetAggregate} [options.aggregate] - The aggregate function to use to combine shared elements
      * @param {CollectionTtl} [options.ttl] - If the set does not exist, it is created with the given `ttl`.
      *                                 If it exists, it is overwritten with the result and its ttl is set to the given `ttl`
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheSortedSetUnionStore.Response>}
      * {@link CacheSortedSetUnionStore.Success} containing the length of the set which contains the result of the union.
      * {@link CacheSortedSetUnionStore.Error} on failure.
@@ -976,75 +1061,89 @@ export declare abstract class AbstractCacheClient implements ICacheClient {
      * Return the type of the key in the cache
      * @param {string} cacheName - The cache containing the key.
      * @param {string} key - The key for which type is requested.
+     * @param {ItemGetTypeOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheItemGetType.Response>}
      * {@link CacheItemGetType.Hit} containing type of key when found.
      * {@link CacheItemGetType.Miss} when the key does not exist.
      * {@link CacheItemGetType.Error} on failure.
      */
-    itemGetType(cacheName: string, key: string | Uint8Array): Promise<CacheItemGetType.Response>;
+    itemGetType(cacheName: string, key: string | Uint8Array, options?: ItemGetTypeOptions): Promise<CacheItemGetType.Response>;
     /**
      * Return the remaining ttl of the key in the cache in milliseconds.
      * @param {string} cacheName - The cache containing the key.
      * @param {string} key - The key for which the ttl remaining is requested.
+     * @param {ItemGetTtlOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheItemGetTtl.Response>}
      * {@link CacheItemGetTtl.Hit} containing ttl remaining of key when found.
      * {@link CacheItemGetTtl.Miss} when the key does not exist.
      * {@link CacheItemGetTtl.Error} on failure.
      */
-    itemGetTtl(cacheName: string, key: string | Uint8Array): Promise<CacheItemGetTtl.Response>;
+    itemGetTtl(cacheName: string, key: string | Uint8Array, options?: ItemGetTtlOptions): Promise<CacheItemGetTtl.Response>;
     /**
      * Check if the provided key exists in the cache
      * @param {string} cacheName - The cache to look in.
      * @param {string | Uint8Array} key - The key to look up.
+     * @param {KeyExistsOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheKeyExists.Response>}
      * {@link CacheKeyExists.Success} returns boolean indicating whether the key was found.
      * {@link CacheKeyExists.Error} on failure.
      */
-    keyExists(cacheName: string, key: string | Uint8Array): Promise<CacheKeyExists.Response>;
+    keyExists(cacheName: string, key: string | Uint8Array, options?: KeyExistsOptions): Promise<CacheKeyExists.Response>;
     /**
      * Check if the provided keys exist in the cache
      * @param {string} cacheName - The cache to look in.
      * @param {string[] | Uint8Array[]} keys - The keys to look up.
+     * @param {KeyExistsOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheKeysExist.Response>}
      * {@link CacheKeysExist.Success} returns list of booleans indicating whether each key was found.
      * {@link CacheKeysExist.Error} on failure.
      */
-    keysExist(cacheName: string, keys: string[] | Uint8Array[]): Promise<CacheKeysExist.Response>;
+    keysExist(cacheName: string, keys: string[] | Uint8Array[], options?: KeyExistsOptions): Promise<CacheKeysExist.Response>;
     /**
      * Update the ttl of the key in the cache in milliseconds.
      * @param {string} cacheName - The cache containing the key.
      * @param {string} key - The key for which the ttl remaining is requested.
      * @param {number} ttlMilliseconds - The ttl in milliseconds that should overwrite the current ttl.
+     * @param {UpdateTtlOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheUpdateTtl.Response>}
      * {@link CacheUpdateTtl.Set} when the ttl was successfully overwritten.
      * {@link CacheUpdateTtl.Miss} when the key does not exist.
      * {@link CacheUpdateTtl.Error} on failure.
      */
-    updateTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number): Promise<CacheUpdateTtl.Response>;
+    updateTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number, options?: UpdateTtlOptions): Promise<CacheUpdateTtl.Response>;
     /**
      * Increase the ttl of the key in the cache in milliseconds.
      * @param {string} cacheName - The cache containing the key.
      * @param {string} key - The key for which the ttl remaining is requested.
      * @param {number} ttlMilliseconds - The ttl in milliseconds that should
      * overwrite the current ttl. Should be greater than the current ttl.
+     * @param {IncreaseTtlOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheIncreaseTtl.Response>}
      * {@link CacheIncreaseTtl.Set} when the ttl was successfully increased.
      * {@link CacheIncreaseTtl.Miss} when the key does not exist.
      * {@link CacheIncreaseTtl.Error} on failure.
      */
-    increaseTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number): Promise<CacheIncreaseTtl.Response>;
+    increaseTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number, options?: IncreaseTtlOptions): Promise<CacheIncreaseTtl.Response>;
     /**
      * Decrease the ttl of the key in the cache in milliseconds.
      * @param {string} cacheName - The cache containing the key.
      * @param {string} key - The key for which the ttl remaining is requested.
      * @param {number} ttlMilliseconds - The ttl in milliseconds that should
      * overwrite the current ttl. Should be less than the current ttl.
+     * @param {DecreaseTtlOptions} options
+     * @param {AbortSignal} options.abortSignal - The signal to cancel the operation
      * @returns {Promise<CacheDecreaseTtl.Response>}
      * {@link CacheDecreaseTtl.Set} when the ttl was successfully decreased.
      * {@link CacheDecreaseTtl.Miss} when the key does not exist.
      * {@link CacheDecreaseTtl.Error} on failure.
      */
-    decreaseTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number): Promise<CacheDecreaseTtl.Response>;
+    decreaseTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number, options?: DecreaseTtlOptions): Promise<CacheDecreaseTtl.Response>;
     private getNextDataClient;
     abstract close(): void;
 }