@gomomento/sdk-core 1.12.8

package/dist/src/internal/clients/cache/AbstractCacheClient.js

@@ -0,0 +1,870 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractCacheClient = void 0;
+class AbstractCacheClient {
+    constructor(controlClient, dataClients) {
+        this.controlClient = controlClient;
+        this.dataClients = dataClients;
+        // We round-robin the requests through all of our clients.  Since javascript
+        // is single-threaded, we don't have to worry about thread safety on this
+        // index variable.
+        this.nextDataClientIndex = 0;
+    }
+    /**
+     * 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.
+     */
+    async createCache(cacheName) {
+        return await this.controlClient.createCache(cacheName);
+    }
+    /**
+     * 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.
+     */
+    async deleteCache(cacheName) {
+        return await this.controlClient.deleteCache(cacheName);
+    }
+    /**
+     * Lists all caches.
+     *
+     * @returns {Promise<ListCaches.Response>} -
+     * {@link ListCaches.Success} containing the list on success.
+     * {@link ListCaches.Error} on failure.
+     */
+    async listCaches() {
+        return await this.controlClient.listCaches();
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async get(cacheName, key) {
+        return await this.getNextDataClient().get(cacheName, key);
+    }
+    /**
+     * 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.
+     * Uses the client's default TTL if this is not supplied.
+     * @returns {Promise<CacheSet.Response>} -
+     * {@link CacheSet.Success} on success.
+     * {@link CacheSet.Error} on failure.
+     */
+    async set(cacheName, key, value, options) {
+        const client = this.getNextDataClient();
+        return await client.set(cacheName, key, value, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheDelete.Response>} -
+     * {@link CacheDelete.Success} on success.
+     * {@link CacheDelete.Error} on failure.
+     */
+    async delete(cacheName, key) {
+        const client = this.getNextDataClient();
+        return await client.delete(cacheName, key);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheListConcatenateBack.Response>} -
+     * {@link CacheListConcatenateBack.Success} on success.
+     * {@link CacheListConcatenateBack.Error} on failure.
+     */
+    async listConcatenateBack(cacheName, listName, values, options) {
+        const client = this.getNextDataClient();
+        return await client.listConcatenateBack(cacheName, listName, values, options === null || options === void 0 ? void 0 : options.truncateFrontToSize, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheListConcatenateFront.Response>} -
+     * {@link CacheListConcatenateFront.Success} on success.
+     * {@link CacheListConcatenateFront.Error} on failure.
+     */
+    async listConcatenateFront(cacheName, listName, values, options) {
+        const client = this.getNextDataClient();
+        return await client.listConcatenateFront(cacheName, listName, values, options === null || options === void 0 ? void 0 : options.truncateBackToSize, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async listFetch(cacheName, listName, options) {
+        const client = this.getNextDataClient();
+        return await client.listFetch(cacheName, listName, options === null || options === void 0 ? void 0 : options.startIndex, options === null || options === void 0 ? void 0 : options.endIndex);
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async listLength(cacheName, listName) {
+        const client = this.getNextDataClient();
+        return await client.listLength(cacheName, listName);
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async listPopBack(cacheName, listName) {
+        const client = this.getNextDataClient();
+        return await client.listPopBack(cacheName, listName);
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async listPopFront(cacheName, listName) {
+        const client = this.getNextDataClient();
+        return await client.listPopFront(cacheName, listName);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheListPushBack.Response>} -
+     * {@link CacheListPushBack.Success} containing the list's new length on
+     * success.
+     * {@link CacheListPushBack.Error} on failure.
+     */
+    async listPushBack(cacheName, listName, value, options) {
+        const client = this.getNextDataClient();
+        return await client.listPushBack(cacheName, listName, value, options === null || options === void 0 ? void 0 : options.truncateFrontToSize, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheListPushFront.Response>} -
+     * {@link CacheListPushFront.Success} containing the list's new length on
+     * success.
+     * {@link CacheListPushFront.Error} on failure.
+     */
+    async listPushFront(cacheName, listName, value, options) {
+        const client = this.getNextDataClient();
+        return await client.listPushFront(cacheName, listName, value, options === null || options === void 0 ? void 0 : options.truncateBackToSize, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async listRemoveValue(cacheName, listName, value) {
+        const client = this.getNextDataClient();
+        return await client.listRemoveValue(cacheName, listName, value);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheListRetain.Response>} -
+     * {@link CacheListRetain.Success} on success.
+     * {@link CacheListRetain.Error} on failure.
+     */
+    async listRetain(cacheName, listName, options) {
+        const client = this.getNextDataClient();
+        return await client.listRetain(cacheName, listName, options === null || options === void 0 ? void 0 : options.startIndex, options === null || options === void 0 ? void 0 : options.endIndex, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * Fetches all elements of the given set
+     *
+     * @param {string} cacheName - The cache containing the set.
+     * @param {string} setName - The set to fetch.
+     * @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.
+     */
+    async setFetch(cacheName, setName) {
+        const client = this.getNextDataClient();
+        return await client.setFetch(cacheName, setName);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheSetAddElement.Response>} -
+     * {@link CacheSetAddElement.Success} on success.
+     * {@link CacheSetAddElement.Error} on failure.
+     */
+    async setAddElement(cacheName, setName, element, options) {
+        return (await this.setAddElements(cacheName, setName, [element], options)).toSingularResponse();
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheSetAddElements.Response>} -
+     * {@link CacheSetAddElements.Success} on success.
+     * {@link CacheSetAddElements.Error} on failure.
+     */
+    async setAddElements(cacheName, setName, elements, options) {
+        const client = this.getNextDataClient();
+        return await client.setAddElements(cacheName, setName, elements, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async setRemoveElement(cacheName, setName, element) {
+        return (await this.setRemoveElements(cacheName, setName, [element])).toSingularResponse();
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async setRemoveElements(cacheName, setName, elements) {
+        const client = this.getNextDataClient();
+        return await client.setRemoveElements(cacheName, setName, elements);
+    }
+    /**
+     * Associates the given key with the given value. If a value for the key is
+     * already present it is not 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} field - The value to be stored.
+     * @param {SetIfNotExistsOptions} [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.
+     * @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.
+     */
+    async setIfNotExists(cacheName, key, field, options) {
+        const client = this.getNextDataClient();
+        return await client.setIfNotExists(cacheName, key, field, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * 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.
+     */
+    async flushCache(cacheName) {
+        return await this.controlClient.flushCache(cacheName);
+    }
+    /**
+     * Fetches all elements of the given dictionary.
+     *
+     * @param {string} cacheName - The cache to perform the lookup in.
+     * @param {string} dictionaryName - The dictionary to fetch.
+     * @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.
+     */
+    async dictionaryFetch(cacheName, dictionaryName) {
+        const client = this.getNextDataClient();
+        return await client.dictionaryFetch(cacheName, dictionaryName);
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async increment(cacheName, field, amount = 1, options) {
+        const client = this.getNextDataClient();
+        return await client.increment(cacheName, field, amount, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheDictionarySetField.Response>} -
+     * {@link CacheDictionarySetField.Success} on success.
+     * {@link CacheDictionarySetField.Error} on failure.
+     */
+    async dictionarySetField(cacheName, dictionaryName, field, value, options) {
+        const client = this.getNextDataClient();
+        return await client.dictionarySetField(cacheName, dictionaryName, field, value, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheDictionarySetFields.Response>} -
+     * {@link CacheDictionarySetFields.Success} on success.
+     * {@link CacheDictionarySetFields.Error} on failure.
+     */
+    async dictionarySetFields(cacheName, dictionaryName, elements, options) {
+        const client = this.getNextDataClient();
+        return await client.dictionarySetFields(cacheName, dictionaryName, elements, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async dictionaryGetField(cacheName, dictionaryName, field) {
+        const client = this.getNextDataClient();
+        return await client.dictionaryGetField(cacheName, dictionaryName, field);
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async dictionaryGetFields(cacheName, dictionaryName, fields) {
+        const client = this.getNextDataClient();
+        return await client.dictionaryGetFields(cacheName, dictionaryName, fields);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheDictionaryRemoveField.Response>} -
+     * {@link CacheDictionaryRemoveField.Success} on success.
+     * {@link CacheDictionaryRemoveField.Error} on failure.
+     */
+    async dictionaryRemoveField(cacheName, dictionaryName, field) {
+        const client = this.getNextDataClient();
+        return await client.dictionaryRemoveField(cacheName, dictionaryName, field);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheDictionaryRemoveFields.Response>} -
+     * {@link CacheDictionaryRemoveFields.Success} on success.
+     * {@link CacheDictionaryRemoveFields.Error} on failure.
+     */
+    async dictionaryRemoveFields(cacheName, dictionaryName, fields) {
+        const client = this.getNextDataClient();
+        return await client.dictionaryRemoveFields(cacheName, dictionaryName, fields);
+    }
+    /**
+     * 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.
+     * @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.
+     */
+    async dictionaryIncrement(cacheName, dictionaryName, field, amount = 1, options) {
+        const client = this.getNextDataClient();
+        return await client.dictionaryIncrement(cacheName, dictionaryName, field, amount, options === null || options === void 0 ? void 0 : options.ttl);
+    }
+    /**
+     * 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.
+     * @returns {Promise<CacheSortedSetPutElement.Response>} -
+     * {@link CacheSortedSetPutElement.Success} on success.
+     * {@link CacheSortedSetPutElement.Error} on failure.
+     * @returns
+     */
+    // public async sortedSetPutElement(
+    //   cacheName: string,
+    //   sortedSetName: string,
+    //   value: string | Uint8Array,
+    //   score: number,
+    //   options?: SortedSetPutElementOptions
+    // ): Promise<CacheSortedSetPutElement.Response> {
+    //   const client = this.getNextDataClient();
+    //   return await client.sortedSetPutElement(
+    //     cacheName,
+    //     sortedSetName,
+    //     value,
+    //     score,
+    //     options?.ttl
+    //   );
+    // }
+    /**
+     * 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.
+     * @returns {Promise<CacheSortedSetPutElements.Response>} -
+     * {@link CacheSortedSetPutElements.Success} on success.
+     * {@link CacheSortedSetPutElements.Error} on failure.
+     * @returns
+     */
+    // public async sortedSetPutElements(
+    //   cacheName: string,
+    //   sortedSetName: string,
+    //   elements: Map<string | Uint8Array, number> | Record<string, number>,
+    //   options?: SortedSetPutElementsOptions
+    // ): Promise<CacheSortedSetPutElements.Response> {
+    //   const client = this.getNextDataClient();
+    //   return await client.sortedSetPutElements(
+    //     cacheName,
+    //     sortedSetName,
+    //     elements,
+    //     options?.ttl
+    //   );
+    // }
+    // sorted set put values
+    /**
+     * 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.
+     * @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.
+     */
+    // public async sortedSetFetchByRank(
+    //   cacheName: string,
+    //   sortedSetName: string,
+    //   options?: SortedSetFetchByRankOptions
+    // ): Promise<CacheSortedSetFetch.Response> {
+    //   const client = this.getNextDataClient();
+    //   return await client.sortedSetFetchByRank(
+    //     cacheName,
+    //     sortedSetName,
+    //     options?.order ?? SortedSetOrder.Ascending,
+    //     options?.startRank ?? 0,
+    //     options?.endRank
+    //   );
+    // }
+    /**
+     * 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.
+     * @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.
+     */
+    // public async sortedSetFetchByScore(
+    //   cacheName: string,
+    //   sortedSetName: string,
+    //   options?: SortedSetFetchByScoreOptions
+    // ): Promise<CacheSortedSetFetch.Response> {
+    //   const client = this.getNextDataClient();
+    //   return await client.sortedSetFetchByScore(
+    //     cacheName,
+    //     sortedSetName,
+    //     options?.order ?? SortedSetOrder.Ascending,
+    //     options?.minScore,
+    //     options?.maxScore,
+    //     options?.offset,
+    //     options?.count
+    //   );
+    // }
+    /**
+     * 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.
+     * @returns {Promise<CacheSortedSetGetRank.Response>}
+     * {@link CacheSortedGetRank.Hit} containing the rank of the requested elements when found.
+     * {@link CacheSortedGetRank.Miss} when the element does not exist.
+     * {@link CacheSortedGetRank.Error} on failure.
+     */
+    // public async sortedSetGetRank(
+    //   cacheName: string,
+    //   sortedSetName: string,
+    //   value: string | Uint8Array
+    // ): Promise<CacheSortedSetGetRank.Response> {
+    //   const client = this.getNextDataClient();
+    //   return await client.sortedSetGetRank(cacheName, sortedSetName, value);
+    // }
+    /**
+     * 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.
+     * @returns {Promise<CacheSortedSetGetScore.Response>}
+     * {@link CacheSortedGetScore.Hit} containing the score of the requested element when found.
+     * {@link CacheSortedGetScore.Miss} when the element or collection does not exist.
+     * {@link CacheSortedGetScore.Error} on failure.
+     */
+    // public async sortedSetGetScore(
+    //   cacheName: string,
+    //   sortedSetName: string,
+    //   value: string | Uint8Array
+    // ): Promise<CacheSortedSetGetScore.Response> {
+    //   const client = this.getNextDataClient();
+    //   return await client.sortedSetGetScore(cacheName, sortedSetName, value);
+    // }
+    /**
+     * 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.
+     * @returns {Promise<CacheSortedSetGetScores.Response>}
+     * {@link CacheSortedGetScores.Hit} containing the scores of the requested elements when found.
+     * {@link CacheSortedGetScores.Miss} when the element or collection does not exist.
+     * {@link CacheSortedGetScores.Error} on failure.
+     */
+    // public async sortedSetGetScores(
+    //   cacheName: string,
+    //   sortedSetName: string,
+    //   values: string[] | Uint8Array[]
+    // ): Promise<CacheSortedSetGetScores.Response> {
+    //   const client = this.getNextDataClient();
+    //   return await client.sortedSetGetScores(cacheName, sortedSetName, values);
+    // }
+    /**
+     * 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.
+     * @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.
+     */
+    // public async sortedSetIncrementScore(
+    //   cacheName: string,
+    //   sortedSetName: string,
+    //   value: string | Uint8Array,
+    //   amount = 1,
+    //   options?: SortedSetIncrementOptions
+    // ): Promise<CacheSortedSetIncrementScore.Response> {
+    //   const client = this.getNextDataClient();
+    //   return await client.sortedSetIncrementScore(
+    //     cacheName,
+    //     sortedSetName,
+    //     value,
+    //     amount,
+    //     options?.ttl
+    //   );
+    // }
+    /**
+     * 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.
+     * @returns {Promise<CacheSortedSetRemoveElement.Response>}
+     * {@link CacheSortedSetRemoveElement.Success} if the element was successfully removed
+     * {@link CacheSortedSetIncrementScore.Error} on failure
+     */
+    // public async sortedSetRemoveElement(
+    //   cacheName: string,
+    //   sortedSetName: string,
+    //   value: string | Uint8Array
+    // ): Promise<CacheSortedSetRemoveElement.Response> {
+    //   const client = this.getNextDataClient();
+    //   return await client.sortedSetRemoveElement(cacheName, sortedSetName, value);
+    // }
+    /**
+     * 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.
+     * @returns {Promise<CacheSortedSetRemoveElement.Response>}
+     * {@link CacheSortedSetRemoveElement.Success} if the elements were successfully removed
+     * {@link CacheSortedSetIncrementScore.Error} on failure
+     */
+    // public async sortedSetRemoveElements(
+    //   cacheName: string,
+    //   sortedSetName: string,
+    //   values: string[] | Uint8Array[]
+    // ): Promise<CacheSortedSetRemoveElements.Response> {
+    //   const client = this.getNextDataClient();
+    //   return await client.sortedSetRemoveElements(
+    //     cacheName,
+    //     sortedSetName,
+    //     values
+    //   );
+    // }
+    /**
+     * Creates a Momento signing key.
+     *
+     * @param {number} ttlMinutes - The time to live in minutes until the Momento
+     * signing key expires.
+     * @returns {Promise<CreateSigningKey.Response>} -
+     * {@link CreateSigningKey.Success} containing the key, key ID, endpoint, and
+     * expiration date on success.
+     * {@link CreateSigningKey.Error} on failure.
+     */
+    // public async createSigningKey(
+    //   ttlMinutes: number
+    // ): Promise<CreateSigningKey.Response> {
+    //   return await this.controlClient.createSigningKey(
+    //     ttlMinutes,
+    //     this.dataClient.getEndpoint()
+    //   );
+    // }
+    /**
+     * Revokes a Momento signing key.
+     *
+     * @remarks
+     * All tokens signed by this key will be invalid.
+     *
+     * @param {string} keyId - The ID of the key to revoke.
+     * @returns {Promise<RevokeSigningKey.Response>} -
+     * {@link RevokeSigningKey.Success} on success.
+     * {@link RevokeSigningKey.Error} on failure.
+     */
+    // public async revokeSigningKey(
+    //   keyId: string
+    // ): Promise<RevokeSigningKey.Response> {
+    //   return await this.controlClient.revokeSigningKey(keyId);
+    // }
+    getNextDataClient() {
+        const client = this.dataClients[this.nextDataClientIndex];
+        this.nextDataClientIndex =
+            (this.nextDataClientIndex + 1) % this.dataClients.length;
+        return client;
+    }
+}
+exports.AbstractCacheClient = AbstractCacheClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AbstractCacheClient.js","sourceRoot":"","sources":["../../../../../src/internal/clients/cache/AbstractCacheClient.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CreateCache,\n  DeleteCache,\n  ListCaches,\n  CacheFlush,\n  CacheGet,\n  CacheSet,\n  CacheDelete,\n  CacheIncrement,\n  IncrementOptions,\n  CacheSetIfNotExists,\n  SetIfNotExistsOptions,\n  CacheSetFetch,\n  CacheSetAddElement,\n  CacheSetAddElements,\n  CacheSetRemoveElement,\n  CacheSetRemoveElements,\n  CacheListFetch,\n  CacheListLength,\n  CacheListPushFront,\n  CacheListPushBack,\n  CacheListConcatenateBack,\n  CacheListConcatenateFront,\n  CacheListPopBack,\n  CacheListPopFront,\n  CacheListRemoveValue,\n  CacheListRetain,\n  CacheDictionarySetField,\n  CacheDictionarySetFields,\n  CacheDictionaryGetField,\n  CacheDictionaryGetFields,\n  CacheDictionaryIncrement,\n  CacheDictionaryFetch,\n  CacheDictionaryRemoveField,\n  CacheDictionaryRemoveFields,\n} from '../../../index';\nimport {ListFetchCallOptions, ListRetainCallOptions} from '../../../utils';\nimport {\n  ICacheClient,\n  SetOptions,\n  SetAddElementOptions,\n  SetAddElementsOptions,\n  ListPushFrontOptions,\n  ListPushBackOptions,\n  ListConcatenateBackOptions,\n  ListConcatenateFrontOptions,\n  DictionarySetFieldOptions,\n  DictionaryIncrementOptions,\n} from './ICacheClient';\nimport {IControlClient} from './IControlClient';\nimport {IDataClient} from './IDataClient';\n\nexport abstract class AbstractCacheClient implements ICacheClient {\n  // making these protected until we fully abstract away the nodejs client\n  protected readonly controlClient: IControlClient;\n  protected readonly dataClients: IDataClient[];\n  protected nextDataClientIndex: number;\n\n  constructor(controlClient: IControlClient, dataClients: IDataClient[]) {\n    this.controlClient = controlClient;\n    this.dataClients = dataClients;\n\n    // We round-robin the requests through all of our clients.  Since javascript\n    // is single-threaded, we don't have to worry about thread safety on this\n    // index variable.\n    this.nextDataClientIndex = 0;\n  }\n\n  /**\n   * Creates a cache if it does not exist.\n   *\n   * @param {string} cacheName - The cache to be created.\n   * @returns {Promise<CreateCache.Response>} -\n   * {@link CreateCache.Success} on success.\n   * {@link CreateCache.AlreadyExists} if the cache already exists.\n   * {@link CreateCache.Error} on failure.\n   */\n  public async createCache(cacheName: string): Promise<CreateCache.Response> {\n    return await this.controlClient.createCache(cacheName);\n  }\n\n  /**\n   * Deletes a cache and all items stored in it.\n   *\n   * @param {string} cacheName - The cache to delete.\n   * @returns {Promise<DeleteCache.Response>} -\n   * {@link DeleteCache.Success} on success.\n   * {@link DeleteCache.Error} on failure.\n   */\n  public async deleteCache(cacheName: string): Promise<DeleteCache.Response> {\n    return await this.controlClient.deleteCache(cacheName);\n  }\n\n  /**\n   * Lists all caches.\n   *\n   * @returns {Promise<ListCaches.Response>} -\n   * {@link ListCaches.Success} containing the list on success.\n   * {@link ListCaches.Error} on failure.\n   */\n  public async listCaches(): Promise<ListCaches.Response> {\n    return await this.controlClient.listCaches();\n  }\n\n  /**\n   * Gets the value stored for the given key.\n   *\n   * @param {string} cacheName - The cache to perform the lookup in.\n   * @param {string | Uint8Array} key - The key to look up.\n   * @returns {Promise<CacheGet.Response>} -\n   * {@link CacheGet.Hit} containing the value if one is found.\n   * {@link CacheGet.Miss} if the key does not exist.\n   * {@link CacheGet.Error} on failure.\n   */\n  public async get(\n    cacheName: string,\n    key: string | Uint8Array\n  ): Promise<CacheGet.Response> {\n    return await this.getNextDataClient().get(cacheName, key);\n  }\n\n  /**\n   * Associates the given key with the given value. If a value for the key is\n   * already present it is replaced with the new value.\n   *\n   * @param {string} cacheName - The cache to store the value in.\n   * @param {string | Uint8Array} key - The key to set.\n   * @param {string | Uint8Array} value - The value to be stored.\n   * @param {SetOptions} [options]\n   * @param {number} [options.ttl] - The time to live for the item in the cache.\n   * Uses the client's default TTL if this is not supplied.\n   * @returns {Promise<CacheSet.Response>} -\n   * {@link CacheSet.Success} on success.\n   * {@link CacheSet.Error} on failure.\n   */\n  public async set(\n    cacheName: string,\n    key: string | Uint8Array,\n    value: string | Uint8Array,\n    options?: SetOptions\n  ): Promise<CacheSet.Response> {\n    const client = this.getNextDataClient();\n    return await client.set(cacheName, key, value, options?.ttl);\n  }\n\n  /**\n   * Removes the given key from the cache. The key can represent a single value\n   * or a collection.\n   *\n   * @param {string} cacheName - The cache to delete from.\n   * @param {string | Uint8Array} key - The key to delete.\n   * @returns {Promise<CacheDelete.Response>} -\n   * {@link CacheDelete.Success} on success.\n   * {@link CacheDelete.Error} on failure.\n   */\n  public async delete(\n    cacheName: string,\n    key: string | Uint8Array\n  ): Promise<CacheDelete.Response> {\n    const client = this.getNextDataClient();\n    return await client.delete(cacheName, key);\n  }\n\n  /**\n   * Adds multiple elements to the back of the given list. Creates the list if\n   * it does not already exist.\n   *\n   * @param {string} cacheName - The cache to store the list in.\n   * @param {string} listName - The list to add to.\n   * @param {string[] | Uint8Array[]} values - The elements to add to the list.\n   * @param {ListConcatenateBackOptions} [options]\n   * @param {number} [options.truncateFrontToSize] - If the list exceeds this\n   * length, remove excess from the front of the list. Must be positive.\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the list's TTL using the client's default if this is not\n   * supplied.\n   * @returns {Promise<CacheListConcatenateBack.Response>} -\n   * {@link CacheListConcatenateBack.Success} on success.\n   * {@link CacheListConcatenateBack.Error} on failure.\n   */\n  public async listConcatenateBack(\n    cacheName: string,\n    listName: string,\n    values: string[] | Uint8Array[],\n    options?: ListConcatenateBackOptions\n  ): Promise<CacheListConcatenateBack.Response> {\n    const client = this.getNextDataClient();\n    return await client.listConcatenateBack(\n      cacheName,\n      listName,\n      values,\n      options?.truncateFrontToSize,\n      options?.ttl\n    );\n  }\n\n  /**\n   * Adds multiple elements to the front of the given list. Creates the list if\n   * it does not already exist.\n   *\n   * @param {string} cacheName - The cache to store the list in.\n   * @param {string} listName - The list to add to.\n   * @param {string[] | Uint8Array[]} values - The elements to add to the list.\n   * @param {ListConcatenateFrontOptions} [options]\n   * @param {number} [options.truncateBackToSize] - If the list exceeds this\n   * length, remove excess from the back of the list. Must be positive.\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the list's TTL using the client's default if this is not\n   * supplied.\n   * @returns {Promise<CacheListConcatenateFront.Response>} -\n   * {@link CacheListConcatenateFront.Success} on success.\n   * {@link CacheListConcatenateFront.Error} on failure.\n   */\n  public async listConcatenateFront(\n    cacheName: string,\n    listName: string,\n    values: string[] | Uint8Array[],\n    options?: ListConcatenateFrontOptions\n  ): Promise<CacheListConcatenateFront.Response> {\n    const client = this.getNextDataClient();\n    return await client.listConcatenateFront(\n      cacheName,\n      listName,\n      values,\n      options?.truncateBackToSize,\n      options?.ttl\n    );\n  }\n\n  /**\n   * Fetches all elements of the given list.\n   *\n   * @param {string} cacheName - The cache containing the list.\n   * @param {string} listName - The list to fetch.\n   * @param {ListFetchCallOptions} [options]\n   * @param {number} [options.startIndex] - Start inclusive index for fetch operation.\n   * @param {number} [options.endIndex] - End exclusive index for fetch operation.\n   * @returns {Promise<CacheListFetch.Response>} -\n   * {@link CacheListFetch.Hit} containing the list elements if the list exists.\n   * {@link CacheListFetch.Miss} if the list does not exist.\n   * {@link CacheListFetch.Error} on failure.\n   */\n  public async listFetch(\n    cacheName: string,\n    listName: string,\n    options?: ListFetchCallOptions\n  ): Promise<CacheListFetch.Response> {\n    const client = this.getNextDataClient();\n    return await client.listFetch(\n      cacheName,\n      listName,\n      options?.startIndex,\n      options?.endIndex\n    );\n  }\n\n  /**\n   * Gets the number of elements in the given list.\n   *\n   * @param {string} cacheName - The cache containing the list.\n   * @param {string} listName - The list to get the length of.\n   * @returns {Promise<CacheListLength.Response>} -\n   * {@link CacheListLength.Hit} containing the length if the list exists.\n   * {@link CacheListLength.Miss} if the list does not exist.\n   * {@link CacheListLength.Error} on failure.\n   */\n  public async listLength(\n    cacheName: string,\n    listName: string\n  ): Promise<CacheListLength.Response> {\n    const client = this.getNextDataClient();\n    return await client.listLength(cacheName, listName);\n  }\n\n  /**\n   * Gets and removes the last value from the given list.\n   *\n   * @param {string} cacheName - The cache containing the list.\n   * @param {string} listName - The list to pop.\n   * @returns {Promise<CacheListPopBack.Response>} -\n   * {@link CacheListPopBack.Hit} containing the element if the list exists.\n   * {@link CacheListPopBack.Miss} if the list does not exist.\n   * {@link CacheListPopBack.Error} on failure.\n   */\n  public async listPopBack(\n    cacheName: string,\n    listName: string\n  ): Promise<CacheListPopBack.Response> {\n    const client = this.getNextDataClient();\n    return await client.listPopBack(cacheName, listName);\n  }\n\n  /**\n   * Gets and removes the first value from the given list.\n   *\n   * @param {string} cacheName - The cache containing the list.\n   * @param {string} listName - The list to pop.\n   * @returns {Promise<CacheListPopFront.Response>} -\n   * {@link CacheListPopFront.Hit} containing the element if the list exists.\n   * {@link CacheListPopFront.Miss} if the list does not exist.\n   * {@link CacheListPopFront.Error} on failure.\n   */\n  public async listPopFront(\n    cacheName: string,\n    listName: string\n  ): Promise<CacheListPopFront.Response> {\n    const client = this.getNextDataClient();\n    return await client.listPopFront(cacheName, listName);\n  }\n\n  /**\n   * Adds an element to the back of the given list. Creates the list if\n   * it does not already exist.\n   *\n   * @param {string} cacheName - The cache to store the list in.\n   * @param {string} listName - The list to push to.\n   * @param {string | Uint8Array} value - The value to push.\n   * @param {ListPushBackOptions} [options]\n   * @param {number} [options.truncateFrontToSize] - If the list exceeds this\n   * length, remove excess from the front of the list. Must be positive.\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the list's TTL using the client's default if this is not\n   * supplied.\n   * @returns {Promise<CacheListPushBack.Response>} -\n   * {@link CacheListPushBack.Success} containing the list's new length on\n   * success.\n   * {@link CacheListPushBack.Error} on failure.\n   */\n  public async listPushBack(\n    cacheName: string,\n    listName: string,\n    value: string | Uint8Array,\n    options?: ListPushBackOptions\n  ): Promise<CacheListPushBack.Response> {\n    const client = this.getNextDataClient();\n    return await client.listPushBack(\n      cacheName,\n      listName,\n      value,\n      options?.truncateFrontToSize,\n      options?.ttl\n    );\n  }\n\n  /**\n   * Adds an element to the front of the given list. Creates the list if\n   * it does not already exist.\n   *\n   * @param {string} cacheName - The cache to store the list in.\n   * @param {string} listName - The list to push to.\n   * @param {string | Uint8Array} value - The value to push.\n   * @param {ListPushFrontOptions} [options]\n   * @param {number} [options.truncateBackToSize] - If the list exceeds this\n   * length, remove excess from the end of the list. Must be positive.\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the list's TTL using the client's default if this is not\n   * supplied.\n   * @returns {Promise<CacheListPushFront.Response>} -\n   * {@link CacheListPushFront.Success} containing the list's new length on\n   * success.\n   * {@link CacheListPushFront.Error} on failure.\n   */\n  public async listPushFront(\n    cacheName: string,\n    listName: string,\n    value: string | Uint8Array,\n    options?: ListPushFrontOptions\n  ): Promise<CacheListPushFront.Response> {\n    const client = this.getNextDataClient();\n    return await client.listPushFront(\n      cacheName,\n      listName,\n      value,\n      options?.truncateBackToSize,\n      options?.ttl\n    );\n  }\n\n  /**\n   * Removes all elements from the given list equal to the given value.\n   *\n   * @param {string} cacheName - The cache containing the list.\n   * @param {string} listName - The list to remove from.\n   * @param {string | Uint8Array} value - The value to remove.\n   * @returns {Promise<CacheListRemoveValue.Response>} -\n   * {@link CacheListRemoveValue.Success} on success. Removing an element that\n   * does not occur in the list or removing from a non-existent list counts as a\n   * success.\n   * {@link CacheListRemoveValue.Error} on failure.\n   */\n  public async listRemoveValue(\n    cacheName: string,\n    listName: string,\n    value: string | Uint8Array\n  ): Promise<CacheListRemoveValue.Response> {\n    const client = this.getNextDataClient();\n    return await client.listRemoveValue(cacheName, listName, value);\n  }\n\n  /**\n   * Retains slice of elements of a given list, deletes the rest of the list\n   * that isn't being retained. Returns a Success or Error.\n   *\n   * @param {string} cacheName - The cache containing the list.\n   * @param {string} listName - The list to retain a slice of.\n   * @param {ListRetainCallOptions} [options]\n   * @param {number} [options.startIndex] - Start inclusive index for fetch\n   * operation. Defaults to start of array if not given, 0.\n   * @param {number} [options.endIndex] - End exclusive index for fetch\n   * operation. Defaults to end of array if not given.\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the list's TTL using the client's default if this is not\n   * supplied.\n   * @returns {Promise<CacheListRetain.Response>} -\n   * {@link CacheListRetain.Success} on success.\n   * {@link CacheListRetain.Error} on failure.\n   */\n  public async listRetain(\n    cacheName: string,\n    listName: string,\n    options?: ListRetainCallOptions\n  ): Promise<CacheListRetain.Response> {\n    const client = this.getNextDataClient();\n    return await client.listRetain(\n      cacheName,\n      listName,\n      options?.startIndex,\n      options?.endIndex,\n      options?.ttl\n    );\n  }\n\n  /**\n   * Fetches all elements of the given set\n   *\n   * @param {string} cacheName - The cache containing the set.\n   * @param {string} setName - The set to fetch.\n   * @returns {Promise<CacheSetFetch.Response>} -\n   * {@link CacheSetFetch.Hit} containing the set elements if the set exists.\n   * {@link CacheSetFetch.Miss} if the set does not exist.\n   * {@link CacheSetFetch.Error} on failure.\n   */\n  public async setFetch(\n    cacheName: string,\n    setName: string\n  ): Promise<CacheSetFetch.Response> {\n    const client = this.getNextDataClient();\n    return await client.setFetch(cacheName, setName);\n  }\n\n  /**\n   * Adds an element to the given set. Creates the set if it does not already\n   * exist.\n   *\n   * @remarks\n   * After this operation the set will contain the union of the element passed\n   * in and the original elements of the set.\n   *\n   * @param {string} cacheName - The cache to store the set in.\n   * @param {string} setName - The set to add to.\n   * @param {string | Uint8Array} element - The element to add.\n   * @param {SetAddElementOptions} options\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the set's TTL using the client's default if this is not supplied.\n   * @returns {Promise<CacheSetAddElement.Response>} -\n   * {@link CacheSetAddElement.Success} on success.\n   * {@link CacheSetAddElement.Error} on failure.\n   */\n  public async setAddElement(\n    cacheName: string,\n    setName: string,\n    element: string | Uint8Array,\n    options?: SetAddElementOptions\n  ): Promise<CacheSetAddElement.Response> {\n    return (\n      await this.setAddElements(\n        cacheName,\n        setName,\n        [element] as string[] | Uint8Array[],\n        options\n      )\n    ).toSingularResponse();\n  }\n\n  /**\n   * Adds multiple elements to the given set. Creates the set if it does not\n   * already exist.\n   *\n   * @remarks\n   * After this operation, the set will contain the union of the elements passed\n   * in and the original elements of the set.\n   *\n   * @param {string} cacheName - The cache to store the set in.\n   * @param {string} setName - The set to add to.\n   * @param {string[] | Uint8Array[]} elements - The elements to add.\n   * @param {SetAddElementsOptions} options\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the set's TTL using the client's default if this is not supplied.\n   * @returns {Promise<CacheSetAddElements.Response>} -\n   * {@link CacheSetAddElements.Success} on success.\n   * {@link CacheSetAddElements.Error} on failure.\n   */\n  public async setAddElements(\n    cacheName: string,\n    setName: string,\n    elements: string[] | Uint8Array[],\n    options?: SetAddElementsOptions\n  ): Promise<CacheSetAddElements.Response> {\n    const client = this.getNextDataClient();\n    return await client.setAddElements(\n      cacheName,\n      setName,\n      elements,\n      options?.ttl\n    );\n  }\n\n  /**\n   * Removes an element from the given set.\n   *\n   * @param {string} cacheName - The cache containing the set.\n   * @param {string} setName - The set to remove from.\n   * @param {string | Uint8Array} element - The element to remove.\n   * @returns {Promise<CacheSetRemoveElement.Response>} -\n   * {@link CacheSetRemoveElement.Success} on success. Removing an element that\n   * does not occur in the set or removing from a non-existent set counts as a\n   * success.\n   * {@link CacheSetRemoveElement.Error} on failure.\n   */\n  public async setRemoveElement(\n    cacheName: string,\n    setName: string,\n    element: string | Uint8Array\n  ): Promise<CacheSetRemoveElement.Response> {\n    return (\n      await this.setRemoveElements(cacheName, setName, [element] as\n        | string[]\n        | Uint8Array[])\n    ).toSingularResponse();\n  }\n\n  /**\n   * Removes multiple elements from the given set.\n   *\n   * @param {string} cacheName - The cache containing the set.\n   * @param {string} setName - The set to remove from.\n   * @param {string[] | Uint8Array[]} elements - The elements to remove.\n   * @returns {Promise<CacheSetRemoveElements.Response>} -\n   * {@link CacheSetRemoveElements.Success} on success. Removing elements that\n   * do not occur in the set or removing from a non-existent set counts as a\n   * success.\n   * {@link CacheSetRemoveElements.Error} on failure.\n   */\n  public async setRemoveElements(\n    cacheName: string,\n    setName: string,\n    elements: string[] | Uint8Array[]\n  ): Promise<CacheSetRemoveElements.Response> {\n    const client = this.getNextDataClient();\n    return await client.setRemoveElements(cacheName, setName, elements);\n  }\n\n  /**\n   * Associates the given key with the given value. If a value for the key is\n   * already present it is not replaced with the new value.\n   *\n   * @param {string} cacheName - The cache to store the value in.\n   * @param {string | Uint8Array} key - The key to set.\n   * @param {string | Uint8Array} field - The value to be stored.\n   * @param {SetIfNotExistsOptions} [options]\n   * @param {number} [options.ttl] - The time to live for the item in the cache.\n   * Uses the client's default TTL if this is not supplied.\n   * @returns {Promise<CacheSetIfNotExists.Response>} -\n   * {@link CacheSetIfNotExists.Stored} on storing the new value.\n   * {@link CacheSetIfNotExists.NotStored} on not storing the new value.\n   * {@link CacheSetIfNotExists.Error} on failure.\n   */\n  public async setIfNotExists(\n    cacheName: string,\n    key: string | Uint8Array,\n    field: string | Uint8Array,\n    options?: SetIfNotExistsOptions\n  ): Promise<CacheSetIfNotExists.Response> {\n    const client = this.getNextDataClient();\n    return await client.setIfNotExists(cacheName, key, field, options?.ttl);\n  }\n\n  /**\n   * Flushes / clears all the items of the given cache\n   *\n   * @param {string} cacheName - The cache to be flushed.\n   * @returns {Promise<CacheFlush.Response>} -\n   * {@link CacheFlush.Success} on success.\n   * {@link CacheFlush.Error} on failure.\n   */\n  public async flushCache(cacheName: string): Promise<CacheFlush.Response> {\n    return await this.controlClient.flushCache(cacheName);\n  }\n\n  /**\n   * Fetches all elements of the given dictionary.\n   *\n   * @param {string} cacheName - The cache to perform the lookup in.\n   * @param {string} dictionaryName - The dictionary to fetch.\n   * @returns {Promise<CacheDictionaryFetch.Response>} -\n   * {@link CacheDictionaryFetch.Hit} containing the dictionary elements if the\n   * dictionary exists.\n   * {@link CacheDictionaryFetch.Miss} if the dictionary does not exist.\n   * {@link CacheDictionaryFetch.Error} on failure.\n   */\n  public async dictionaryFetch(\n    cacheName: string,\n    dictionaryName: string\n  ): Promise<CacheDictionaryFetch.Response> {\n    const client = this.getNextDataClient();\n    return await client.dictionaryFetch(cacheName, dictionaryName);\n  }\n\n  /**\n   * Adds an integer quantity to a field value.\n   *\n   * @remarks\n   * Incrementing the value of a missing field sets the value to amount.\n   *\n   * @param {string} cacheName - The cache containing the field.\n   * @param {string | Uint8Array} field - The field to increment.\n   * @param {number} amount - The quantity to add to the value. May be positive,\n   * negative, or zero. Defaults to 1.\n   * @param {IncrementOptions} options\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * @returns {Promise<CacheIncrement>} -\n   * {@link CacheIncrement.Success} containing the incremented value\n   * on success.\n   * {@link CacheIncrement.Error} on failure. Incrementing a value\n   * that was not set using this method or is not the string representation of\n   * an integer results in a failure with a FailedPreconditionException error.\n   */\n  public async increment(\n    cacheName: string,\n    field: string | Uint8Array,\n    amount = 1,\n    options?: IncrementOptions\n  ): Promise<CacheIncrement.Response> {\n    const client = this.getNextDataClient();\n    return await client.increment(cacheName, field, amount, options?.ttl);\n  }\n\n  /**\n   * Adds an element to the given dictionary. Creates the dictionary if it does\n   * not already exist.\n   *\n   * @param {string} cacheName - The cache to store the dictionary in.\n   * @param {string} dictionaryName - The dictionary to add to.\n   * @param {string | Uint8Array} field - The field to set.\n   * @param {string | Uint8Array} value - The value to store.\n   * @param {DictionarySetFieldOptions} options\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the dictionary's TTL using the client's default if this is not\n   * supplied.\n   * @returns {Promise<CacheDictionarySetField.Response>} -\n   * {@link CacheDictionarySetField.Success} on success.\n   * {@link CacheDictionarySetField.Error} on failure.\n   */\n  public async dictionarySetField(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array,\n    value: string | Uint8Array,\n    options?: DictionarySetFieldOptions\n  ): Promise<CacheDictionarySetField.Response> {\n    const client = this.getNextDataClient();\n    return await client.dictionarySetField(\n      cacheName,\n      dictionaryName,\n      field,\n      value,\n      options?.ttl\n    );\n  }\n\n  /**\n   * Adds multiple elements to the given dictionary. Creates the dictionary if\n   * it does not already exist.\n   *\n   * @param {string} cacheName - The cache to store the dictionary in.\n   * @param {string} dictionaryName - The dictionary to add to.\n   * @param {Map<string | Uint8Array, string | Uint8Array>} elements - The\n   * elements to set.\n   * @param {DictionarySetFieldsOptions} options\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the dictionary's TTL using the client's default if this is not\n   * supplied.\n   * @returns {Promise<CacheDictionarySetFields.Response>} -\n   * {@link CacheDictionarySetFields.Success} on success.\n   * {@link CacheDictionarySetFields.Error} on failure.\n   */\n  public async dictionarySetFields(\n    cacheName: string,\n    dictionaryName: string,\n    elements:\n      | Map<string | Uint8Array, string | Uint8Array>\n      | Record<string, string | Uint8Array>,\n    options?: DictionarySetFieldOptions\n  ): Promise<CacheDictionarySetFields.Response> {\n    const client = this.getNextDataClient();\n    return await client.dictionarySetFields(\n      cacheName,\n      dictionaryName,\n      elements,\n      options?.ttl\n    );\n  }\n\n  /**\n   * Gets the value stored for the given dictionary and field.\n   *\n   * @param {string} cacheName - The cache containing the dictionary.\n   * @param {string} dictionaryName - The dictionary to look up.\n   * @param {string | Uint8Array} field - The field to look up.\n   * @returns {Promise<CacheDictionaryGetField.Response>} -\n   * {@link CacheDictionaryGetField.Hit} containing the dictionary element if\n   * one is found.\n   * {@link CacheDictionaryGetField.Miss} if the dictionary does not exist.\n   * {@link CacheDictionaryGetField.Error} on failure.\n   */\n  public async dictionaryGetField(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array\n  ): Promise<CacheDictionaryGetField.Response> {\n    const client = this.getNextDataClient();\n    return await client.dictionaryGetField(cacheName, dictionaryName, field);\n  }\n\n  /**\n   * Gets multiple values from the given dictionary.\n   *\n   * @param {string} cacheName - The cache containing the dictionary.\n   * @param {string} dictionaryName - The dictionary to look up.\n   * @param {string[] | Uint8Array[]} fields - The fields to look up.\n   * @returns {Promise<CacheDictionaryGetFields.Response>} -\n   * {@link CacheDictionaryGetFields.Hit} containing the dictionary elements if\n   * the dictionary exists.\n   * {@link CacheDictionaryGetFields.Miss} if the dictionary does not exist.\n   * {@link CacheDictionaryGetFields.Error} on failure.\n   */\n  public async dictionaryGetFields(\n    cacheName: string,\n    dictionaryName: string,\n    fields: string[] | Uint8Array[]\n  ): Promise<CacheDictionaryGetFields.Response> {\n    const client = this.getNextDataClient();\n    return await client.dictionaryGetFields(cacheName, dictionaryName, fields);\n  }\n\n  /**\n   * Removes an element from the given dictionary.\n   *\n   * @remarks\n   * Performs a no-op if the dictionary or field does not exist.\n   *\n   * @param {string} cacheName - The cache containing the dictionary.\n   * @param {string} dictionaryName - The dictionary to remove from.\n   * @param {string | Uint8Array} field - The field to remove.\n   * @returns {Promise<CacheDictionaryRemoveField.Response>} -\n   * {@link CacheDictionaryRemoveField.Success} on success.\n   * {@link CacheDictionaryRemoveField.Error} on failure.\n   */\n  public async dictionaryRemoveField(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array\n  ): Promise<CacheDictionaryRemoveField.Response> {\n    const client = this.getNextDataClient();\n    return await client.dictionaryRemoveField(cacheName, dictionaryName, field);\n  }\n\n  /**\n   * Removes multiple fields from the given dictionary.\n   *\n   * @remarks\n   * Performs a no-op if the dictionary or fields do not exist.\n   *\n   * @param {string} cacheName - The cache containing the dictionary.\n   * @param {string} dictionaryName - The dictionary to remove from.\n   * @param {string[] | Uint8Array[]} fields - The fields to remove.\n   * @returns {Promise<CacheDictionaryRemoveFields.Response>} -\n   * {@link CacheDictionaryRemoveFields.Success} on success.\n   * {@link CacheDictionaryRemoveFields.Error} on failure.\n   */\n  public async dictionaryRemoveFields(\n    cacheName: string,\n    dictionaryName: string,\n    fields: string[] | Uint8Array[]\n  ): Promise<CacheDictionaryRemoveFields.Response> {\n    const client = this.getNextDataClient();\n    return await client.dictionaryRemoveFields(\n      cacheName,\n      dictionaryName,\n      fields\n    );\n  }\n\n  /**\n   * Adds an integer quantity to a dictionary value.\n   *\n   * @remarks\n   * Incrementing the value of a missing field sets the value to amount.\n   *\n   * @param {string} cacheName - The cache containing the dictionary.\n   * @param {string} dictionaryName - The dictionary to set.\n   * @param {string | Uint8Array} field - The field to increment.\n   * @param {number} amount - The quantity to add to the value. May be positive,\n   * negative, or zero. Defaults to 1.\n   * @param {DictionaryIncrementOptions} options\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the dictionary's TTL using the client's default if this is not\n   * supplied.\n   * @returns {Promise<CacheDictionaryIncrement.Response>} -\n   * {@link CacheDictionaryIncrement.Success} containing the incremented value\n   * on success.\n   * {@link CacheDictionaryIncrement.Error} on failure. Incrementing a value\n   * that was not set using this method or is not the string representation of\n   * an integer results in a failure with a FailedPreconditionException error.\n   */\n  public async dictionaryIncrement(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array,\n    amount = 1,\n    options?: DictionaryIncrementOptions\n  ): Promise<CacheDictionaryIncrement.Response> {\n    const client = this.getNextDataClient();\n    return await client.dictionaryIncrement(\n      cacheName,\n      dictionaryName,\n      field,\n      amount,\n      options?.ttl\n    );\n  }\n\n  /**\n   * Adds an element to the given sorted set. If the element already exists, its\n   * score is updated. Creates the sorted set if it does not exist.\n   *\n   * @param {string} cacheName - The cache containing the sorted set.\n   * @param {string} sortedSetName - The sorted set to add to.\n   * @param {string | Uint8Array} value - The value to add.\n   * @param {number} score - The score to assign to the value.\n   * @param {SortedSetPutElementOptions} options\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the sorted set's TTL using the client's default if this is not\n   * supplied.\n   * @returns {Promise<CacheSortedSetPutElement.Response>} -\n   * {@link CacheSortedSetPutElement.Success} on success.\n   * {@link CacheSortedSetPutElement.Error} on failure.\n   * @returns\n   */\n  // public async sortedSetPutElement(\n  //   cacheName: string,\n  //   sortedSetName: string,\n  //   value: string | Uint8Array,\n  //   score: number,\n  //   options?: SortedSetPutElementOptions\n  // ): Promise<CacheSortedSetPutElement.Response> {\n  //   const client = this.getNextDataClient();\n  //   return await client.sortedSetPutElement(\n  //     cacheName,\n  //     sortedSetName,\n  //     value,\n  //     score,\n  //     options?.ttl\n  //   );\n  // }\n\n  /**\n   * Adds elements to the given sorted set. For any values that already exist, it\n   * the score is updated. Creates the sorted set if it does not exist.\n   *\n   * @param {string} cacheName - The cache containing the sorted set.\n   * @param {string} sortedSetName - The sorted set to add to.\n   * @param {Map<string | Uint8Array, number>| Record<string, number>} elements - The value->score pairs to add to the sorted set.\n   * @param {SortedSetPutElementOptions} options\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the sorted set's TTL using the client's default if this is not\n   * supplied.\n   * @returns {Promise<CacheSortedSetPutElements.Response>} -\n   * {@link CacheSortedSetPutElements.Success} on success.\n   * {@link CacheSortedSetPutElements.Error} on failure.\n   * @returns\n   */\n  // public async sortedSetPutElements(\n  //   cacheName: string,\n  //   sortedSetName: string,\n  //   elements: Map<string | Uint8Array, number> | Record<string, number>,\n  //   options?: SortedSetPutElementsOptions\n  // ): Promise<CacheSortedSetPutElements.Response> {\n  //   const client = this.getNextDataClient();\n  //   return await client.sortedSetPutElements(\n  //     cacheName,\n  //     sortedSetName,\n  //     elements,\n  //     options?.ttl\n  //   );\n  // }\n\n  // sorted set put values\n\n  /**\n   * Fetch the elements in the given sorted set by index (rank).\n   *\n   * @param {string} cacheName - The cache containing the sorted set.\n   * @param {string} sortedSetName - The sorted set to fetch from.\n   * @param {SortedSetFetchByRankOptions} options\n   * @param {number} [options.startRank] - The rank of the first element to\n   * fetch. Defaults to 0. This rank is inclusive, ie the element at this rank\n   * will be fetched.\n   * @param {number} [options.endRank] - The rank of the last element to fetch.\n   * This rank is exclusive, ie the element at this rank will not be fetched.\n   * Defaults to null, which fetches up until and including the last element.\n   * @param {SortedSetOrder} [options.order] - The order to fetch the elements in.\n   * Defaults to ascending.\n   * @returns {Promise<CacheSortedSetFetch.Response>}\n   * {@link CacheSortedSetFetch.Hit} containing the requested elements when found.\n   * {@link CacheSortedSetFetch.Miss} when the sorted set does not exist.\n   * {@link CacheSortedSetFetch.Error} on failure.\n   */\n  // public async sortedSetFetchByRank(\n  //   cacheName: string,\n  //   sortedSetName: string,\n  //   options?: SortedSetFetchByRankOptions\n  // ): Promise<CacheSortedSetFetch.Response> {\n  //   const client = this.getNextDataClient();\n  //   return await client.sortedSetFetchByRank(\n  //     cacheName,\n  //     sortedSetName,\n  //     options?.order ?? SortedSetOrder.Ascending,\n  //     options?.startRank ?? 0,\n  //     options?.endRank\n  //   );\n  // }\n\n  /**\n   * Fetch the elements in the given sorted set by score.\n   *\n   * @param {string} cacheName - The cache containing the sorted set.\n   * @param {string} sortedSetName - The sorted set to fetch from.\n   * @param {SortedSetFetchByScoreOptions} options\n   * @param {number} [options.minScore] - The minimum score (inclusive) of the\n   * elements to fetch. Defaults to negative infinity.\n   * @param {number} [options.maxScore] - The maximum score (inclusive) of the\n   * elements to fetch. Defaults to positive infinity.\n   * @param {SortedSetOrder} [options.order] - The order to fetch the elements in.\n   * Defaults to ascending.\n   * @param {number} [options.offset] - The number of elements to skip before\n   * returning the first element. Defaults to 0. Note: this is not the rank of\n   * the first element to return, but the number of elements of the result set\n   * to skip before returning the first element.\n   * @param {number} [options.count] - The maximum number of elements to return.\n   * Defaults to undefined, which returns all elements.\n   * @returns {Promise<CacheSortedSetFetch.Response>} -\n   * {@link CacheSortedSetFetch.Hit} containing the requested elements when found.\n   * {@link CacheSortedSetFetch.Miss} when the sorted set does not exist.\n   * {@link CacheSortedSetFetch.Error} on failure.\n   */\n  // public async sortedSetFetchByScore(\n  //   cacheName: string,\n  //   sortedSetName: string,\n  //   options?: SortedSetFetchByScoreOptions\n  // ): Promise<CacheSortedSetFetch.Response> {\n  //   const client = this.getNextDataClient();\n  //   return await client.sortedSetFetchByScore(\n  //     cacheName,\n  //     sortedSetName,\n  //     options?.order ?? SortedSetOrder.Ascending,\n  //     options?.minScore,\n  //     options?.maxScore,\n  //     options?.offset,\n  //     options?.count\n  //   );\n  // }\n\n  /**\n   * Look up the rank of an element in the sorted set, by the value of the element.\n   *\n   * @param {string} cacheName - The cache containing the sorted set.\n   * @param {string} sortedSetName - The sorted set to fetch from.\n   * @param {string | Uint8Array} value - The value of the element whose rank we are retrieving.\n   * @returns {Promise<CacheSortedSetGetRank.Response>}\n   * {@link CacheSortedGetRank.Hit} containing the rank of the requested elements when found.\n   * {@link CacheSortedGetRank.Miss} when the element does not exist.\n   * {@link CacheSortedGetRank.Error} on failure.\n   */\n  // public async sortedSetGetRank(\n  //   cacheName: string,\n  //   sortedSetName: string,\n  //   value: string | Uint8Array\n  // ): Promise<CacheSortedSetGetRank.Response> {\n  //   const client = this.getNextDataClient();\n  //   return await client.sortedSetGetRank(cacheName, sortedSetName, value);\n  // }\n\n  /**\n   * Look up the score of an element in the sorted set, by the value of the element.\n   *\n   * @param {string} cacheName - The cache containing the sorted set.\n   * @param {string} sortedSetName - The sorted set to fetch from.\n   * @param {string | Uint8Array} value - The value of the element whose score we are retrieving.\n   * @returns {Promise<CacheSortedSetGetScore.Response>}\n   * {@link CacheSortedGetScore.Hit} containing the score of the requested element when found.\n   * {@link CacheSortedGetScore.Miss} when the element or collection does not exist.\n   * {@link CacheSortedGetScore.Error} on failure.\n   */\n  // public async sortedSetGetScore(\n  //   cacheName: string,\n  //   sortedSetName: string,\n  //   value: string | Uint8Array\n  // ): Promise<CacheSortedSetGetScore.Response> {\n  //   const client = this.getNextDataClient();\n  //   return await client.sortedSetGetScore(cacheName, sortedSetName, value);\n  // }\n\n  /**\n   * Look up the scores of multiple elements in the sorted set, by the value of the elements.\n   *\n   * @param {string} cacheName - The cache containing the sorted set.\n   * @param {string} sortedSetName - The sorted set to fetch from.\n   * @param {string[] | Uint8Array[]} values - The values of the elements whose scores we are retrieving.\n   * @returns {Promise<CacheSortedSetGetScores.Response>}\n   * {@link CacheSortedGetScores.Hit} containing the scores of the requested elements when found.\n   * {@link CacheSortedGetScores.Miss} when the element or collection does not exist.\n   * {@link CacheSortedGetScores.Error} on failure.\n   */\n  // public async sortedSetGetScores(\n  //   cacheName: string,\n  //   sortedSetName: string,\n  //   values: string[] | Uint8Array[]\n  // ): Promise<CacheSortedSetGetScores.Response> {\n  //   const client = this.getNextDataClient();\n  //   return await client.sortedSetGetScores(cacheName, sortedSetName, values);\n  // }\n\n  /**\n   * Increment the score of an element in the sorted set.\n   *\n   * @param {string} cacheName - The cache containing the sorted set.\n   * @param {string} sortedSetName - The sorted set to fetch from.\n   * @param {string | Uint8Array} value - The value of the element whose score we are incrementing.\n   * @param {number} amount - The quantity to add to the score. May be positive,\n   * negative, or zero. Defaults to 1.\n   * @param {SortedSetIncrementOptions} options\n   * @param {CollectionTtl} [options.ttl] - How the TTL should be managed.\n   * Refreshes the sorted set's TTL using the client's default if this is not\n   * supplied.\n   * @returns {Promise<CacheSortedSetIncrementScore.Response>} -\n   * {@link CacheSortedSetIncrementScore.Success} containing the incremented score\n   * on success.\n   * {@link CacheSortedSetIncrementScore.Error} on failure. Incrementing a score\n   * that was not set using this method or is not the string representation of\n   * an integer results in a failure with a FailedPreconditionException error.\n   */\n  // public async sortedSetIncrementScore(\n  //   cacheName: string,\n  //   sortedSetName: string,\n  //   value: string | Uint8Array,\n  //   amount = 1,\n  //   options?: SortedSetIncrementOptions\n  // ): Promise<CacheSortedSetIncrementScore.Response> {\n  //   const client = this.getNextDataClient();\n  //   return await client.sortedSetIncrementScore(\n  //     cacheName,\n  //     sortedSetName,\n  //     value,\n  //     amount,\n  //     options?.ttl\n  //   );\n  // }\n\n  /**\n   * Remove an element from the sorted set\n   * @param {string} cacheName - The cache containing the sorted set.\n   * @param {string} sortedSetName - The sorted set to remove from.\n   * @param {string | Uint8Array} value - The value of the element to remove from the set.\n   * @returns {Promise<CacheSortedSetRemoveElement.Response>}\n   * {@link CacheSortedSetRemoveElement.Success} if the element was successfully removed\n   * {@link CacheSortedSetIncrementScore.Error} on failure\n   */\n  // public async sortedSetRemoveElement(\n  //   cacheName: string,\n  //   sortedSetName: string,\n  //   value: string | Uint8Array\n  // ): Promise<CacheSortedSetRemoveElement.Response> {\n  //   const client = this.getNextDataClient();\n  //   return await client.sortedSetRemoveElement(cacheName, sortedSetName, value);\n  // }\n\n  /**\n   * Remove multiple elements from the sorted set\n   * @param {string} cacheName - The cache containing the sorted set.\n   * @param {string} sortedSetName - The sorted set to remove from.\n   * @param {string | Uint8Array} values - The values of the elements to remove from the set.\n   * @returns {Promise<CacheSortedSetRemoveElement.Response>}\n   * {@link CacheSortedSetRemoveElement.Success} if the elements were successfully removed\n   * {@link CacheSortedSetIncrementScore.Error} on failure\n   */\n  // public async sortedSetRemoveElements(\n  //   cacheName: string,\n  //   sortedSetName: string,\n  //   values: string[] | Uint8Array[]\n  // ): Promise<CacheSortedSetRemoveElements.Response> {\n  //   const client = this.getNextDataClient();\n  //   return await client.sortedSetRemoveElements(\n  //     cacheName,\n  //     sortedSetName,\n  //     values\n  //   );\n  // }\n\n  /**\n   * Creates a Momento signing key.\n   *\n   * @param {number} ttlMinutes - The time to live in minutes until the Momento\n   * signing key expires.\n   * @returns {Promise<CreateSigningKey.Response>} -\n   * {@link CreateSigningKey.Success} containing the key, key ID, endpoint, and\n   * expiration date on success.\n   * {@link CreateSigningKey.Error} on failure.\n   */\n  // public async createSigningKey(\n  //   ttlMinutes: number\n  // ): Promise<CreateSigningKey.Response> {\n  //   return await this.controlClient.createSigningKey(\n  //     ttlMinutes,\n  //     this.dataClient.getEndpoint()\n  //   );\n  // }\n\n  /**\n   * Revokes a Momento signing key.\n   *\n   * @remarks\n   * All tokens signed by this key will be invalid.\n   *\n   * @param {string} keyId - The ID of the key to revoke.\n   * @returns {Promise<RevokeSigningKey.Response>} -\n   * {@link RevokeSigningKey.Success} on success.\n   * {@link RevokeSigningKey.Error} on failure.\n   */\n  // public async revokeSigningKey(\n  //   keyId: string\n  // ): Promise<RevokeSigningKey.Response> {\n  //   return await this.controlClient.revokeSigningKey(keyId);\n  // }\n\n  protected getNextDataClient(): IDataClient {\n    const client = this.dataClients[this.nextDataClientIndex];\n    this.nextDataClientIndex =\n      (this.nextDataClientIndex + 1) % this.dataClients.length;\n    return client;\n  }\n}\n"]}