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, 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';
export declare abstract class AbstractCacheClient implements ICacheClient {
    protected readonly controlClient: IControlClient;
    protected readonly dataClients: IDataClient[];
    protected readonly pingClient?: IPingClient;
    private nextDataClientIndex;
    protected constructor(controlClient: IControlClient, dataClients: IDataClient[], pingClient?: IPingClient);
    cache(cacheName: string): IMomentoCache;
    /**
     * Ping the service to verify it is up and running
     */
    ping(): Promise<void>;
    /**
     * Creates a cache if it does not exist.
     *
     * @param {string} cacheName - The cache to be created.
     * @returns {Promise<CreateCache.Response>} -
     * {@link CreateCache.Success} on success.
     * {@link CreateCache.AlreadyExists} if the cache already exists.
     * {@link CreateCache.Error} on failure.
     */
    createCache(cacheName: string, options?: ControlCallOptions): Promise<CreateCache.Response>;
    /**
     * Deletes a cache and all items stored in it.
     *
     * @param {string} cacheName - The cache to delete.
     * @returns {Promise<DeleteCache.Response>} -
     * {@link DeleteCache.Success} on success.
     * {@link DeleteCache.Error} on failure.
     */
    deleteCache(cacheName: string, options?: ControlCallOptions): Promise<DeleteCache.Response>;
    /**
     * Lists all caches.
     *
     * @returns {Promise<ListCaches.Response>} -
     * {@link ListCaches.Success} containing the list on success.
     * {@link ListCaches.Error} on failure.
     */
    listCaches(options?: ControlCallOptions): Promise<ListCaches.Response>;
    /**
     * Gets the value stored for the given key.
     *
     * @param {string} cacheName - The cache to perform the lookup in.
     * @param {string | Uint8Array} key - The key to look up.
     * @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.
     * {@link CacheGet.Error} on failure.
     */
    get(cacheName: string, key: string | Uint8Array, options?: GetOptions): Promise<CacheGet.Response>;
    /**
     * Gets the value stored for the given key and its hash.
     *
     * @param {string} cacheName - The cache to perform the lookup in.
     * @param {string | Uint8Array} key - The key to look up.
     * @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.
     * {@link CacheGetWithHash.Error} on failure.
     */
    getWithHash(cacheName: string, key: string | Uint8Array, options?: GetWithHashOptions): Promise<CacheGetWithHash.Response>;
    /**
     * Associates the given key with the given value. If a value for the key is
     * already present it is replaced with the new value.
     *
     * @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 {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>} -
     * {@link CacheSet.Success} on success.
     * {@link CacheSet.Error} on failure.
     */
    set(cacheName: string, key: string | Uint8Array, value: string | Uint8Array, options?: SetOptions): Promise<CacheSet.Response>;
    /**
     * Associates the given key with the given value. If a value for the key is
     * already present it is replaced with the new value. Returns the hash of the value.
     *
     * @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 {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.
     * {@link CacheSetWithHash.Error} on failure.
     */
    setWithHash(cacheName: string, key: string | Uint8Array, value: string | Uint8Array, options?: SetWithHashOptions): Promise<CacheSetWithHash.Response>;
    /**
     * Removes the given key from the cache. The key can represent a single value
     * or a collection.
     *
     * @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, options?: DeleteOptions): Promise<CacheDelete.Response>;
    /**
     * Gets the value stored for the given keys.
     *
     * @param {string} cacheName - The cache to perform the lookup in.
     * @param {string[] | Uint8Array[]} keys - The list of keys to look up.
     * @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.
     */
    getBatch(cacheName: string, keys: Array<string | Uint8Array>, options?: GetBatchOptions): Promise<CacheGetBatch.Response>;
    /**
     * Associates the given keys with the given values. If a value for the key is
     * already present it is replaced with the new value.
     *
     * @param {string} cacheName - The cache to store the values in.
     * @param {Record<string, string | Uint8Array | SetBatchItem> | Map<string | Uint8Array, string | Uint8Array | SetBatchItem>} items - The key-value pairs to be stored, with the option to set a TTL per item.
     * @param {SetBatchOptions} [options]
     * @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.
     */
    setBatch(cacheName: string, items: Record<string, string | Uint8Array> | Map<string | Uint8Array, string | Uint8Array> | Array<SetBatchItem>, options?: SetBatchOptions): Promise<CacheSetBatch.Response>;
    /**
     * Adds multiple elements to the back of the given list. Creates the list if
     * it does not already exist.
     *
     * @param {string} cacheName - The cache to store the list in.
     * @param {string} listName - The list to add to.
     * @param {string[] | Uint8Array[]} values - The elements to add to the list.
     * @param {ListConcatenateBackOptions} [options]
     * @param {number} [options.truncateFrontToSize] - If the list exceeds this
     * length, remove excess from the front of the list. Must be positive.
     * @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.
     */
    listConcatenateBack(cacheName: string, listName: string, values: string[] | Uint8Array[], options?: ListConcatenateBackOptions): Promise<CacheListConcatenateBack.Response>;
    /**
     * Adds multiple elements to the front of the given list. Creates the list if
     * it does not already exist.
     *
     * @param {string} cacheName - The cache to store the list in.
     * @param {string} listName - The list to add to.
     * @param {string[] | Uint8Array[]} values - The elements to add to the list.
     * @param {ListConcatenateFrontOptions} [options]
     * @param {number} [options.truncateBackToSize] - If the list exceeds this
     * length, remove excess from the back of the list. Must be positive.
     * @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.
     */
    listConcatenateFront(cacheName: string, listName: string, values: string[] | Uint8Array[], options?: ListConcatenateFrontOptions): Promise<CacheListConcatenateFront.Response>;
    /**
     * Fetches all elements of the given list.
     *
     * @param {string} cacheName - The cache containing the list.
     * @param {string} listName - The list to fetch.
     * @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.
     * {@link CacheListFetch.Error} on failure.
     */
    listFetch(cacheName: string, listName: string, options?: ListFetchCallOptions): Promise<CacheListFetch.Response>;
    /**
     * Gets the number of elements in the given list.
     *
     * @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, 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, 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, options?: ListPopFrontOptions): Promise<CacheListPopFront.Response>;
    /**
     * Adds an element to the back of the given list. Creates the list if
     * it does not already exist.
     *
     * @param {string} cacheName - The cache to store the list in.
     * @param {string} listName - The list to push to.
     * @param {string | Uint8Array} value - The value to push.
     * @param {ListPushBackOptions} [options]
     * @param {number} [options.truncateFrontToSize] - If the list exceeds this
     * length, remove excess from the front of the list. Must be positive.
     * @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.
     * {@link CacheListPushBack.Error} on failure.
     */
    listPushBack(cacheName: string, listName: string, value: string | Uint8Array, options?: ListPushBackOptions): Promise<CacheListPushBack.Response>;
    /**
     * Adds an element to the front of the given list. Creates the list if
     * it does not already exist.
     *
     * @param {string} cacheName - The cache to store the list in.
     * @param {string} listName - The list to push to.
     * @param {string | Uint8Array} value - The value to push.
     * @param {ListPushFrontOptions} [options]
     * @param {number} [options.truncateBackToSize] - If the list exceeds this
     * length, remove excess from the end of the list. Must be positive.
     * @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.
     * {@link CacheListPushFront.Error} on failure.
     */
    listPushFront(cacheName: string, listName: string, value: string | Uint8Array, options?: ListPushFrontOptions): Promise<CacheListPushFront.Response>;
    /**
     * Removes all elements from the given list equal to the given value.
     *
     * @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, 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.
     *
     * @param {string} cacheName - The cache containing the list.
     * @param {string} listName - The list to retain a slice of.
     * @param {ListRetainCallOptions} [options]
     * @param {number} [options.startIndex] - Start inclusive index for fetch
     * operation. Defaults to start of array if not given, 0.
     * @param {number} [options.endIndex] - End exclusive index for fetch
     * operation. Defaults to end of array if not given.
     * @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.
     */
    listRetain(cacheName: string, listName: string, options?: ListRetainCallOptions): Promise<CacheListRetain.Response>;
    /**
     * Fetches all elements of the given set
     *
     * @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, options?: SetFetchOptions): Promise<CacheSetFetch.Response>;
    /**
     * Adds an element to the given set. Creates the set if it does not already
     * exist.
     *
     * @remarks
     * After this operation the set will contain the union of the element passed
     * in and the original elements of the set.
     *
     * @param {string} cacheName - The cache to store the set in.
     * @param {string} setName - The set to add to.
     * @param {string | Uint8Array} element - The element to add.
     * @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.
     */
    setAddElement(cacheName: string, setName: string, element: string | Uint8Array, options?: SetAddElementOptions): Promise<CacheSetAddElement.Response>;
    /**
     * Adds multiple elements to the given set. Creates the set if it does not
     * already exist.
     *
     * @remarks
     * After this operation, the set will contain the union of the elements passed
     * in and the original elements of the set.
     *
     * @param {string} cacheName - The cache to store the set in.
     * @param {string} setName - The set to add to.
     * @param {string[] | Uint8Array[]} elements - The elements to add.
     * @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.
     */
    setAddElements(cacheName: string, setName: string, elements: string[] | Uint8Array[], options?: SetAddElementsOptions): Promise<CacheSetAddElements.Response>;
    /**
     * Tests if the given set contains the given element.
     * @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, 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[], 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, 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[], options?: SetRemoveElementsOptions): Promise<CacheSetRemoveElements.Response>;
    /**
     * Fetch a random sample of elements from the set.
     * Returns a different random sample for each call.
     *
     * @param {string} cacheName - The cache containing the set.
     * @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, 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, 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, options?: SetLengthOptions): Promise<CacheSetLength.Response>;
    /**
     * Associates the given key with the given value if key is not already present in the cache.
     *
     * @deprecated Use setIfAbsent instead.
     * @param {string} cacheName - The cache to store the value in.
     * @param {string | Uint8Array} key - The key to set.
     * @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.
     * {@link CacheSetIfNotExists.NotStored} on not storing the new value.
     * {@link CacheSetIfNotExists.Error} on failure.
     */
    setIfNotExists(cacheName: string, key: string | Uint8Array, field: string | Uint8Array, options?: SetIfNotExistsOptions): Promise<CacheSetIfNotExists.Response>;
    /**
     * Associates the given key with the given value if key is not already present in the cache.
     *
     * @param {string} cacheName - The cache to store the value in.
     * @param {string | Uint8Array} key - The key to set.
     * @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>} -
     * {@link CacheSetIfAbsent.Stored} on storing the new value.
     * {@link CacheSetIfAbsent.NotStored} on not storing the new value.
     * {@link CacheSetIfAbsent.Error} on failure.
     */
    setIfAbsent(cacheName: string, key: string | Uint8Array, field: string | Uint8Array, options?: SetIfAbsentOptions): Promise<CacheSetIfAbsent.Response>;
    /**
     * Associates the given key with the given value if the key is present in the cache.
     *
     * @param {string} cacheName - The cache to store the value in.
     * @param {string | Uint8Array} key - The key to set.
     * @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.
     * {@link CacheSetIfPresent.NotStored} on not storing the new value.
     * {@link CacheSetIfPresent.Error} on failure.
     */
    setIfPresent(cacheName: string, key: string | Uint8Array, field: string | Uint8Array, options?: SetIfPresentOptions): Promise<CacheSetIfPresent.Response>;
    /**
     * Associates the given key with the given value if the key is present in the cache
     * and its value is equal to the supplied `equal` value.
     *
     * @param {string} cacheName - The cache to store the value in.
     * @param {string | Uint8Array} key - The key to set.
     * @param {string | Uint8Array} field - The value to be stored.
     * @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.
     * {@link CacheSetIfEqual.NotStored} on not storing the new value.
     * {@link CacheSetIfEqual.Error} on failure.
     */
    setIfEqual(cacheName: string, key: string | Uint8Array, field: string | Uint8Array, equal: string | Uint8Array, options?: SetIfEqualOptions): Promise<CacheSetIfEqual.Response>;
    /**
     * Associates the given key with the given value if the key does not exist in the cache or
     * if the value for the key is not equal to the supplied `notEqual` parameter.
     *
     * @param {string} cacheName - The cache to store the value in.
     * @param {string | Uint8Array} key - The key to set.
     * @param {string | Uint8Array} field - The value to be stored.
     * @param {string | Uint8Array} notEqual - The value to compare to the cached value.
     * @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.
     * {@link CacheSetIfNotEqual.Error} on failure.
     */
    setIfNotEqual(cacheName: string, key: string | Uint8Array, field: string | Uint8Array, notEqual: string | Uint8Array, options?: SetIfNotEqualOptions): Promise<CacheSetIfNotEqual.Response>;
    /**
     * Associates the given key with the given value if key is present in the cache
     * and its value is not equal to the supplied `notEqual` value.
     *
     * @param {string} cacheName - The cache to store the value in.
     * @param {string | Uint8Array} key - The key to set.
     * @param {string | Uint8Array} field - The value to be stored.
     * @param {string | Uint8Array} notEqual - The value to compare to the cached value.
     * @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.
     * {@link CacheSetIfPresentAndNotEqual.Error} on failure.
     */
    setIfPresentAndNotEqual(cacheName: string, key: string | Uint8Array, field: string | Uint8Array, notEqual: string | Uint8Array, options?: SetIfPresentAndNotEqualOptions): Promise<CacheSetIfPresentAndNotEqual.Response>;
    /**
     * Associates the given key with the given value if key is absent or if the key is
     * present and its value is equal to the given value.
     *
     * @param {string} cacheName - The cache to store the value in.
     * @param {string | Uint8Array} key - The key to set.
     * @param {string | Uint8Array} field - The value to be stored.
     * @param {string | Uint8Array} equal - The value to compare to the cached value.
     * @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.
     * {@link CacheSetIfAbsentOrEqual.Error} on failure.
     */
    setIfAbsentOrEqual(cacheName: string, key: string | Uint8Array, field: string | Uint8Array, equal: string | Uint8Array, options?: SetIfAbsentOrEqualOptions): Promise<CacheSetIfAbsentOrEqual.Response>;
    /**
     * Associates the given key with the given value if key is present in the cache
     * and its hash is equal to the supplied 'hashEqual' hash.
     *
     * @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 {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.
     * {@link CacheSetIfPresentAndHashEqual.NotStored} on not storing the new value.
     * {@link CacheSetIfPresentAndHashEqual.Error} on failure.
     */
    setIfPresentAndHashEqual(cacheName: string, key: string | Uint8Array, value: string | Uint8Array, hashEqual: Uint8Array, options?: SetIfPresentAndHashEqualOptions): Promise<CacheSetIfPresentAndHashEqual.Response>;
    /**
     * Associates the given key with the given value if key is present in the cache
     * and its hash is not equal to the supplied 'hashNotEqual' hash.
     *
     * @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 {Uint8Array} hashNotEqual - The hash to compare to the cached hash.
     * @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.
     * {@link CacheSetIfPresentAndHashNotEqual.Error} on failure.
     */
    setIfPresentAndHashNotEqual(cacheName: string, key: string | Uint8Array, value: string | Uint8Array, hashNotEqual: Uint8Array, options?: SetIfPresentAndHashNotEqualOptions): Promise<CacheSetIfPresentAndHashNotEqual.Response>;
    /**
     * Associates the given key with the given value if key is absent or if the key is
     * present and its value's hash is equal to the given 'hashEqual' hash.
     *
     * @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 {string | Uint8Array} hashEqual - The value to compare to the cached value.
     * @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.
     * {@link CacheSetIfAbsentOrHashEqual.Error} on failure.
     */
    setIfAbsentOrHashEqual(cacheName: string, key: string | Uint8Array, value: string | Uint8Array, hashEqual: Uint8Array, options?: SetIfAbsentOrHashEqualOptions): Promise<CacheSetIfAbsentOrHashEqual.Response>;
    /**
     * Associates the given key with the given value if key is absent or if the key is
     * present and its value's hash is not equal to the given 'hashNotEqual' hash.
     *
     * @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 {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.
     * {@link CacheSetIfAbsentOrHashNotEqual.NotStored} on not storing the new value.
     * {@link CacheSetIfAbsentOrHashNotEqual.Error} on failure.
     */
    setIfAbsentOrHashNotEqual(cacheName: string, key: string | Uint8Array, value: string | Uint8Array, hashNotEqual: Uint8Array, options?: SetIfAbsentOrHashNotEqualOptions): Promise<CacheSetIfAbsentOrHashNotEqual.Response>;
    /**
     * Flushes / clears all the items of the given cache
     *
     * @param {string} cacheName - The cache to be flushed.
     * @returns {Promise<CacheFlush.Response>} -
     * {@link CacheFlush.Success} on success.
     * {@link CacheFlush.Error} on failure.
     */
    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, options?: DictionaryFetchOptions): Promise<CacheDictionaryFetch.Response>;
    /**
     * Adds an integer quantity to a field value.
     *
     * @remarks
     * Incrementing the value of a missing field sets the value to amount.
     *
     * @param {string} cacheName - The cache containing the field.
     * @param {string | Uint8Array} field - The field to increment.
     * @param {number} amount - The quantity to add to the value. May be positive,
     * 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.
     * {@link CacheIncrement.Error} on failure. Incrementing a value
     * that was not set using this method or is not the string representation of
     * an integer results in a failure with a FailedPreconditionException error.
     */
    increment(cacheName: string, field: string | Uint8Array, amount?: number, options?: IncrementOptions): Promise<CacheIncrement.Response>;
    /**
     * Adds an element to the given dictionary. Creates the dictionary if it does
     * not already exist.
     *
     * @param {string} cacheName - The cache to store the dictionary in.
     * @param {string} dictionaryName - The dictionary to add to.
     * @param {string | Uint8Array} field - The field to set.
     * @param {string | Uint8Array} value - The value to store.
     * @param {DictionarySetFieldOptions} options
     * @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.
     */
    dictionarySetField(cacheName: string, dictionaryName: string, field: string | Uint8Array, value: string | Uint8Array, options?: DictionarySetFieldOptions): Promise<CacheDictionarySetField.Response>;
    /**
     * Adds multiple elements to the given dictionary. Creates the dictionary if
     * it does not already exist.
     *
     * @param {string} cacheName - The cache to store the dictionary in.
     * @param {string} dictionaryName - The dictionary to add to.
     * @param {Map<string | Uint8Array, string | Uint8Array>} elements - The
     * elements to set.
     * @param {DictionarySetFieldsOptions} options
     * @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.
     */
    dictionarySetFields(cacheName: string, dictionaryName: string, elements: Map<string | Uint8Array, string | Uint8Array> | Record<string, string | Uint8Array> | Array<[string, string | Uint8Array]>, options?: DictionarySetFieldsOptions): Promise<CacheDictionarySetFields.Response>;
    /**
     * Gets the value stored for the given dictionary and field.
     *
     * @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, 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[], options?: DictionaryGetFieldOptions): Promise<CacheDictionaryGetFields.Response>;
    /**
     * Removes an element from the given dictionary.
     *
     * @remarks
     * Performs a no-op if the dictionary or field does not exist.
     *
     * @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, options?: DictionaryRemoveFieldOptions): Promise<CacheDictionaryRemoveField.Response>;
    /**
     * Removes multiple fields from the given dictionary.
     *
     * @remarks
     * Performs a no-op if the dictionary or fields do not exist.
     *
     * @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[], options?: DictionaryRemoveFieldOptions): Promise<CacheDictionaryRemoveFields.Response>;
    /**
     * Adds an integer quantity to a dictionary value.
     *
     * @remarks
     * Incrementing the value of a missing field sets the value to amount.
     *
     * @param {string} cacheName - The cache containing the dictionary.
     * @param {string} dictionaryName - The dictionary to set.
     * @param {string | Uint8Array} field - The field to increment.
     * @param {number} amount - The quantity to add to the value. May be positive,
     * negative, or zero. Defaults to 1.
     * @param {DictionaryIncrementOptions} options
     * @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.
     * {@link CacheDictionaryIncrement.Error} on failure. Incrementing a value
     * that was not set using this method or is not the string representation of
     * an integer results in a failure with a FailedPreconditionException error.
     */
    dictionaryIncrement(cacheName: string, dictionaryName: string, field: string | Uint8Array, amount?: number, options?: DictionaryIncrementOptions): Promise<CacheDictionaryIncrement.Response>;
    /**
     * Gets the number of elements in the given dictionary.
     *
     * @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, 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.
     *
     * @param {string} cacheName - The cache containing the sorted set.
     * @param {string} sortedSetName - The sorted set to add to.
     * @param {string | Uint8Array} value - The value to add.
     * @param {number} score - The score to assign to the value.
     * @param {SortedSetPutElementOptions} options
     * @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.
     * @returns
     */
    sortedSetPutElement(cacheName: string, sortedSetName: string, value: string | Uint8Array, score: number, options?: SortedSetPutElementOptions): Promise<CacheSortedSetPutElement.Response>;
    /**
     * Adds elements to the given sorted set. For any values that already exist, it
     * the score is updated. Creates the sorted set if it does not exist.
     *
     * @param {string} cacheName - The cache containing the sorted set.
     * @param {string} sortedSetName - The sorted set to add to.
     * @param {Map<string | Uint8Array, number>| Record<string, number>} elements - The value->score pairs to add to the sorted set.
     * @param {SortedSetPutElementOptions} options
     * @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.
     * @returns
     */
    sortedSetPutElements(cacheName: string, sortedSetName: string, elements: Map<string | Uint8Array, number> | Record<string, number> | Array<[string, number]>, options?: SortedSetPutElementsOptions): Promise<CacheSortedSetPutElements.Response>;
    /**
     * Fetch the elements in the given sorted set by index (rank).
     *
     * @param {string} cacheName - The cache containing the sorted set.
     * @param {string} sortedSetName - The sorted set to fetch from.
     * @param {SortedSetFetchByRankOptions} options
     * @param {number} [options.startRank] - The rank of the first element to
     * fetch. Defaults to 0. This rank is inclusive, ie the element at this rank
     * will be fetched.
     * @param {number} [options.endRank] - The rank of the last element to fetch.
     * This rank is exclusive, ie the element at this rank will not be fetched.
     * 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.
     * {@link CacheSortedSetFetch.Error} on failure.
     */
    sortedSetFetchByRank(cacheName: string, sortedSetName: string, options?: SortedSetFetchByRankOptions): Promise<CacheSortedSetFetch.Response>;
    /**
     * Fetch the elements in the given sorted set by score.
     *
     * @param {string} cacheName - The cache containing the sorted set.
     * @param {string} sortedSetName - The sorted set to fetch from.
     * @param {SortedSetFetchByScoreOptions} options
     * @param {number} [options.minScore] - The minimum score (inclusive) of the
     * elements to fetch. Defaults to negative infinity.
     * @param {number} [options.maxScore] - The maximum score (inclusive) of the
     * elements to fetch. Defaults to positive infinity.
     * @param {SortedSetOrder} [options.order] - The order to fetch the elements in.
     * Defaults to ascending.
     * @param {number} [options.offset] - The number of elements to skip before
     * returning the first element. Defaults to 0. Note: this is not the rank of
     * the first element to return, but the number of elements of the result set
     * 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.
     * {@link CacheSortedSetFetch.Error} on failure.
     */
    sortedSetFetchByScore(cacheName: string, sortedSetName: string, options?: SortedSetFetchByScoreOptions): Promise<CacheSortedSetFetch.Response>;
    /**
     * Look up the rank of an element in the sorted set, by the value of the element.
     *
     * @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 rank we are retrieving.
     * @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.
     * {@link CacheSortedSetGetRank.Error} on failure.
     */
    sortedSetGetRank(cacheName: string, sortedSetName: string, value: string | Uint8Array, options?: SortedSetGetRankOptions): Promise<CacheSortedSetGetRank.Response>;
    /**
     * Look up the score of an element in the sorted set, by the value of the element.
     *
     * @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, 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[], options?: SortedSetGetScoreOptions): Promise<CacheSortedSetGetScores.Response>;
    /**
     * Increment the score of an element in the sorted set.
     *
     * @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 incrementing.
     * @param {number} amount - The quantity to add to the score. May be positive,
     * negative, or zero. Defaults to 1.
     * @param {SortedSetIncrementOptions} options
     * @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.
     * {@link CacheSortedSetIncrementScore.Error} on failure. Incrementing a score
     * that was not set using this method or is not the string representation of
     * an integer results in a failure with a FailedPreconditionException error.
     */
    sortedSetIncrementScore(cacheName: string, sortedSetName: string, value: string | Uint8Array, amount?: number, options?: SortedSetIncrementOptions): Promise<CacheSortedSetIncrementScore.Response>;
    /**
     * Remove an element 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} 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, 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[], 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, 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.
     * @param {string} sortedSetName - The sorted set name.
     * @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.
     * {@link CacheSortedSetLengthByScore.Error} on failure.
     */
    sortedSetLengthByScore(cacheName: string, sortedSetName: string, options?: SortedSetLengthByScoreOptions): Promise<CacheSortedSetLengthByScore.Response>;
    /**
     * Computes the union of all source sets and stores the result in itself. Returns the number of elements in the set after
     * sotring the result of the union
     * @param {string} cacheName - The cache containing the sorted set.
     * @param {string} sortedSetName - The sorted set name.
     * @param {SortedSetSource[]} sources - The array of source sets that will be unioned
     * @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.
     */
    sortedSetUnionStore(cacheName: string, sortedSetName: string, sources: SortedSetSource[], options?: SortedSetUnionStoreOptions): Promise<CacheSortedSetUnionStore.Response>;
    /**
     * 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, 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, 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, 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[], 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, 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, 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, options?: DecreaseTtlOptions): Promise<CacheDecreaseTtl.Response>;
    private getNextDataClient;
    abstract close(): void;
}
