@gomomento/sdk-core 1.41.2 → 1.42.1

package/dist/src/messages/responses/leaderboard/leaderboard-remove-elements.d.ts

@@ -0,0 +1,61 @@
+import { SdkError } from '../../../errors';
+import { ResponseBase } from '../response-base';
+/**
+ * Parent response type for a leaderboard remove elements request.  The
+ * response object is resolved to a type-safe object of one of
+ * the following subtypes:
+ *
+ * - {Success}
+ * - {Error}
+ *
+ * `instanceof` type guards can be used to operate on the appropriate subtype.
+ * @example
+ * For example:
+ * ```
+ * if (response instanceof LeaderboardRemoveElements.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `LeaderboardRemoveElements.Error` in this block, so you will have access to the properties
+ *   // of the Error class; e.g. `response.errorCode()`.
+ * }
+ * ```
+ */
+export declare abstract class Response extends ResponseBase {
+}
+declare class _Success extends Response {
+}
+declare const Success_base: {
+    new (...args: any[]): {
+        readonly is_success: boolean;
+    };
+} & typeof _Success;
+/**
+ * Indicates a Successful leaderboard remove elements request.
+ */
+export declare class Success extends Success_base {
+}
+declare class _Error extends Response {
+    protected _innerException: SdkError;
+    constructor(_innerException: SdkError);
+}
+declare const Error_base: {
+    new (...args: any[]): {
+        _innerException: SdkError;
+        message(): string;
+        innerException(): SdkError;
+        errorCode(): import("../../../errors").MomentoErrorCode;
+        toString(): string;
+    };
+} & typeof _Error;
+/**
+ * Indicates that an error occurred during the leaderboard remove elements request.
+ *
+ * This response object includes the following fields that you can use to determine
+ * how you would like to handle the error:
+ *
+ * - `errorCode()` - a unique Momento error code indicating the type of error that occurred.
+ * - `message()` - a human-readable description of the error
+ * - `innerException()` - the original error that caused the failure; can be re-thrown.
+ */
+export declare class Error extends Error_base {
+}
+export {};

package/dist/src/messages/responses/leaderboard/leaderboard-remove-elements.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Error = exports.Success = exports.Response = void 0;
+const response_base_1 = require("../response-base");
+/**
+ * Parent response type for a leaderboard remove elements request.  The
+ * response object is resolved to a type-safe object of one of
+ * the following subtypes:
+ *
+ * - {Success}
+ * - {Error}
+ *
+ * `instanceof` type guards can be used to operate on the appropriate subtype.
+ * @example
+ * For example:
+ * ```
+ * if (response instanceof LeaderboardRemoveElements.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `LeaderboardRemoveElements.Error` in this block, so you will have access to the properties
+ *   // of the Error class; e.g. `response.errorCode()`.
+ * }
+ * ```
+ */
+class Response extends response_base_1.ResponseBase {
+}
+exports.Response = Response;
+class _Success extends Response {
+}
+/**
+ * Indicates a Successful leaderboard remove elements request.
+ */
+class Success extends (0, response_base_1.ResponseSuccess)(_Success) {
+}
+exports.Success = Success;
+class _Error extends Response {
+    constructor(_innerException) {
+        super();
+        this._innerException = _innerException;
+    }
+}
+/**
+ * Indicates that an error occurred during the leaderboard remove elements request.
+ *
+ * This response object includes the following fields that you can use to determine
+ * how you would like to handle the error:
+ *
+ * - `errorCode()` - a unique Momento error code indicating the type of error that occurred.
+ * - `message()` - a human-readable description of the error
+ * - `innerException()` - the original error that caused the failure; can be re-thrown.
+ */
+class Error extends (0, response_base_1.ResponseError)(_Error) {
+}
+exports.Error = Error;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/messages/responses/leaderboard/leaderboard-upsert.d.ts

@@ -0,0 +1,61 @@
+import { SdkError } from '../../../errors';
+import { ResponseBase } from '../response-base';
+/**
+ * Parent response type for a leaderboard upsert request.  The
+ * response object is resolved to a type-safe object of one of
+ * the following subtypes:
+ *
+ * - {Success}
+ * - {Error}
+ *
+ * `instanceof` type guards can be used to operate on the appropriate subtype.
+ * @example
+ * For example:
+ * ```
+ * if (response instanceof LeaderboardUpsert.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `LeaderboardUpsert.Error` in this block, so you will have access to the properties
+ *   // of the Error class; e.g. `response.errorCode()`.
+ * }
+ * ```
+ */
+export declare abstract class Response extends ResponseBase {
+}
+declare class _Success extends Response {
+}
+declare const Success_base: {
+    new (...args: any[]): {
+        readonly is_success: boolean;
+    };
+} & typeof _Success;
+/**
+ * Indicates a Successful leaderboard length request.
+ */
+export declare class Success extends Success_base {
+}
+declare class _Error extends Response {
+    protected _innerException: SdkError;
+    constructor(_innerException: SdkError);
+}
+declare const Error_base: {
+    new (...args: any[]): {
+        _innerException: SdkError;
+        message(): string;
+        innerException(): SdkError;
+        errorCode(): import("../../../errors").MomentoErrorCode;
+        toString(): string;
+    };
+} & typeof _Error;
+/**
+ * Indicates that an error occurred during the leaderboard upsert request.
+ *
+ * This response object includes the following fields that you can use to determine
+ * how you would like to handle the error:
+ *
+ * - `errorCode()` - a unique Momento error code indicating the type of error that occurred.
+ * - `message()` - a human-readable description of the error
+ * - `innerException()` - the original error that caused the failure; can be re-thrown.
+ */
+export declare class Error extends Error_base {
+}
+export {};

package/dist/src/messages/responses/leaderboard/leaderboard-upsert.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Error = exports.Success = exports.Response = void 0;
+const response_base_1 = require("../response-base");
+/**
+ * Parent response type for a leaderboard upsert request.  The
+ * response object is resolved to a type-safe object of one of
+ * the following subtypes:
+ *
+ * - {Success}
+ * - {Error}
+ *
+ * `instanceof` type guards can be used to operate on the appropriate subtype.
+ * @example
+ * For example:
+ * ```
+ * if (response instanceof LeaderboardUpsert.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `LeaderboardUpsert.Error` in this block, so you will have access to the properties
+ *   // of the Error class; e.g. `response.errorCode()`.
+ * }
+ * ```
+ */
+class Response extends response_base_1.ResponseBase {
+}
+exports.Response = Response;
+class _Success extends Response {
+}
+/**
+ * Indicates a Successful leaderboard length request.
+ */
+class Success extends (0, response_base_1.ResponseSuccess)(_Success) {
+}
+exports.Success = Success;
+class _Error extends Response {
+    constructor(_innerException) {
+        super();
+        this._innerException = _innerException;
+    }
+}
+/**
+ * Indicates that an error occurred during the leaderboard upsert request.
+ *
+ * This response object includes the following fields that you can use to determine
+ * how you would like to handle the error:
+ *
+ * - `errorCode()` - a unique Momento error code indicating the type of error that occurred.
+ * - `message()` - a human-readable description of the error
+ * - `innerException()` - the original error that caused the failure; can be re-thrown.
+ */
+class Error extends (0, response_base_1.ResponseError)(_Error) {
+}
+exports.Error = Error;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVhZGVyYm9hcmQtdXBzZXJ0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL21lc3NhZ2VzL3Jlc3BvbnNlcy9sZWFkZXJib2FyZC9sZWFkZXJib2FyZC11cHNlcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0Esb0RBQThFO0FBRTlFOzs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FrQkc7QUFDSCxNQUFzQixRQUFTLFNBQVEsNEJBQVk7Q0FBRztBQUF0RCw0QkFBc0Q7QUFFdEQsTUFBTSxRQUFTLFNBQVEsUUFBUTtDQUFHO0FBRWxDOztHQUVHO0FBQ0gsTUFBYSxPQUFRLFNBQVEsSUFBQSwrQkFBZSxFQUFDLFFBQVEsQ0FBQztDQUFHO0FBQXpELDBCQUF5RDtBQUV6RCxNQUFNLE1BQU8sU0FBUSxRQUFRO0lBQzNCLFlBQXNCLGVBQXlCO1FBQzdDLEtBQUssRUFBRSxDQUFDO1FBRFksb0JBQWUsR0FBZixlQUFlLENBQVU7SUFFL0MsQ0FBQztDQUNGO0FBRUQ7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBYSxLQUFNLFNBQVEsSUFBQSw2QkFBYSxFQUFDLE1BQU0sQ0FBQztDQUFHO0FBQW5ELHNCQUFtRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7U2RrRXJyb3J9IGZyb20gJy4uLy4uLy4uL2Vycm9ycyc7XG5pbXBvcnQge1Jlc3BvbnNlQmFzZSwgUmVzcG9uc2VFcnJvciwgUmVzcG9uc2VTdWNjZXNzfSBmcm9tICcuLi9yZXNwb25zZS1iYXNlJztcblxuLyoqXG4gKiBQYXJlbnQgcmVzcG9uc2UgdHlwZSBmb3IgYSBsZWFkZXJib2FyZCB1cHNlcnQgcmVxdWVzdC4gIFRoZVxuICogcmVzcG9uc2Ugb2JqZWN0IGlzIHJlc29sdmVkIHRvIGEgdHlwZS1zYWZlIG9iamVjdCBvZiBvbmUgb2ZcbiAqIHRoZSBmb2xsb3dpbmcgc3VidHlwZXM6XG4gKlxuICogLSB7U3VjY2Vzc31cbiAqIC0ge0Vycm9yfVxuICpcbiAqIGBpbnN0YW5jZW9mYCB0eXBlIGd1YXJkcyBjYW4gYmUgdXNlZCB0byBvcGVyYXRlIG9uIHRoZSBhcHByb3ByaWF0ZSBzdWJ0eXBlLlxuICogQGV4YW1wbGVcbiAqIEZvciBleGFtcGxlOlxuICogYGBgXG4gKiBpZiAocmVzcG9uc2UgaW5zdGFuY2VvZiBMZWFkZXJib2FyZFVwc2VydC5FcnJvcikge1xuICogICAvLyBIYW5kbGUgZXJyb3IgYXMgYXBwcm9wcmlhdGUuICBUaGUgY29tcGlsZXIgd2lsbCBzbWFydC1jYXN0IGByZXNwb25zZWAgdG8gdHlwZVxuICogICAvLyBgTGVhZGVyYm9hcmRVcHNlcnQuRXJyb3JgIGluIHRoaXMgYmxvY2ssIHNvIHlvdSB3aWxsIGhhdmUgYWNjZXNzIHRvIHRoZSBwcm9wZXJ0aWVzXG4gKiAgIC8vIG9mIHRoZSBFcnJvciBjbGFzczsgZS5nLiBgcmVzcG9uc2UuZXJyb3JDb2RlKClgLlxuICogfVxuICogYGBgXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBSZXNwb25zZSBleHRlbmRzIFJlc3BvbnNlQmFzZSB7fVxuXG5jbGFzcyBfU3VjY2VzcyBleHRlbmRzIFJlc3BvbnNlIHt9XG5cbi8qKlxuICogSW5kaWNhdGVzIGEgU3VjY2Vzc2Z1bCBsZWFkZXJib2FyZCBsZW5ndGggcmVxdWVzdC5cbiAqL1xuZXhwb3J0IGNsYXNzIFN1Y2Nlc3MgZXh0ZW5kcyBSZXNwb25zZVN1Y2Nlc3MoX1N1Y2Nlc3MpIHt9XG5cbmNsYXNzIF9FcnJvciBleHRlbmRzIFJlc3BvbnNlIHtcbiAgY29uc3RydWN0b3IocHJvdGVjdGVkIF9pbm5lckV4Y2VwdGlvbjogU2RrRXJyb3IpIHtcbiAgICBzdXBlcigpO1xuICB9XG59XG5cbi8qKlxuICogSW5kaWNhdGVzIHRoYXQgYW4gZXJyb3Igb2NjdXJyZWQgZHVyaW5nIHRoZSBsZWFkZXJib2FyZCB1cHNlcnQgcmVxdWVzdC5cbiAqXG4gKiBUaGlzIHJlc3BvbnNlIG9iamVjdCBpbmNsdWRlcyB0aGUgZm9sbG93aW5nIGZpZWxkcyB0aGF0IHlvdSBjYW4gdXNlIHRvIGRldGVybWluZVxuICogaG93IHlvdSB3b3VsZCBsaWtlIHRvIGhhbmRsZSB0aGUgZXJyb3I6XG4gKlxuICogLSBgZXJyb3JDb2RlKClgIC0gYSB1bmlxdWUgTW9tZW50byBlcnJvciBjb2RlIGluZGljYXRpbmcgdGhlIHR5cGUgb2YgZXJyb3IgdGhhdCBvY2N1cnJlZC5cbiAqIC0gYG1lc3NhZ2UoKWAgLSBhIGh1bWFuLXJlYWRhYmxlIGRlc2NyaXB0aW9uIG9mIHRoZSBlcnJvclxuICogLSBgaW5uZXJFeGNlcHRpb24oKWAgLSB0aGUgb3JpZ2luYWwgZXJyb3IgdGhhdCBjYXVzZWQgdGhlIGZhaWx1cmU7IGNhbiBiZSByZS10aHJvd24uXG4gKi9cbmV4cG9ydCBjbGFzcyBFcnJvciBleHRlbmRzIFJlc3BvbnNlRXJyb3IoX0Vycm9yKSB7fVxuIl19

package/dist/src/messages/responses/response-base.d.ts

@@ -40,4 +40,10 @@ export declare function ResponseSuccess<TBase extends Constructor>(Base: TBase):
         readonly is_success: boolean;
     };
 } & TBase;
+export declare function ResponseFound<TBase extends Constructor>(Base: TBase): {
+    new (...args: any[]): {};
+} & TBase;
+export declare function ResponseNotFound<TBase extends Constructor>(Base: TBase): {
+    new (...args: any[]): {};
+} & TBase;
 export {};

package/dist/src/messages/responses/response-base.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseSuccess = exports.ResponseMiss = exports.ResponseHit = exports.ResponseError = exports.ResponseBase = void 0;
+exports.ResponseNotFound = exports.ResponseFound = exports.ResponseSuccess = exports.ResponseMiss = exports.ResponseHit = exports.ResponseError = exports.ResponseBase = void 0;
 class ResponseBase {
     toString() {
         return this.constructor.name;
@@ -47,4 +47,14 @@ function ResponseSuccess(Base) {
     };
 }
 exports.ResponseSuccess = ResponseSuccess;
-//# sourceMappingURL=data:application/json;base64,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
+function ResponseFound(Base) {
+    return class ResponseFound extends Base {
+    };
+}
+exports.ResponseFound = ResponseFound;
+function ResponseNotFound(Base) {
+    return class ResponseNotFound extends Base {
+    };
+}
+exports.ResponseNotFound = ResponseNotFound;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/utils/cache-call-options.d.ts

@@ -109,3 +109,68 @@ export interface ListFetchCallOptions {
      */
     endIndex?: number;
 }
+export declare enum LeaderboardOrder {
+    Ascending = "ASC",
+    Descending = "DESC"
+}
+export interface LeaderboardGetRankCallOptions {
+    /**
+     * The order in which to return the elements.
+     * If the order is not specified, the elements are returned in ascending order.
+     * If descending order is used, the start and end ranks are interpreted as if
+     * the leaderboard were reversed.
+     */
+    order?: LeaderboardOrder;
+}
+export interface LeaderboardFetchByRankCallOptions {
+    /**
+     * The rank of the first element to return, inclusive.
+     * If the rank is not specified, defaults to 0.
+     * Ranks can be used to manually paginate through the leaderboard
+     * in batches of 8192 elements (e.g. request 0-8192, then 8192-16384, etc)
+     */
+    startRank?: number;
+    /**
+     * The rank of the last element to return, exclusive.
+     * If the rank is not specified, defaults to 8192.
+     * Ranks can be used to manually paginate through the leaderboard
+     * in batches of 8192 elements (e.g. request 0-8192, then 8192-16384, etc)
+     */
+    endRank?: number;
+    /**
+     * The order in which to return the elements.
+     * If the order is not specified, the elements are returned in ascending order.
+     * If descending order is used, the start and end ranks are interpreted as if
+     * the leaderboard were reversed.
+     */
+    order?: LeaderboardOrder;
+}
+export interface LeaderboardFetchByScoreCallOptions {
+    /**
+     * The minimum score of the elements to return, inclusive.
+     * If the minimum score is not specified, the range extends to the lowest score.
+     */
+    minScore?: number;
+    /**
+     * The maximum score of the elements to return, exclusive.
+     * If the maximum score is not specified, the range extends to the highest score.
+     */
+    maxScore?: number;
+    /**
+     * The order in which to return the elements.
+     * If the order is not specified, the elements are returned in ascending order.
+     */
+    order?: LeaderboardOrder;
+    /**
+     * The index offset of the first element to return, relative to the first element in the result set.
+     * If specified must be non-negative (>= 0).
+     * Defaults to zero, ie. the start at first element in the result set.
+     */
+    offset?: number;
+    /**
+     * The maximum number of elements to return.
+     * If specified must be strictly positive (> 0).
+     * Defaults to 8192, the maximum number of elements that can be returned at a time.
+     */
+    count?: number;
+}

package/dist/src/utils/cache-call-options.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SortedSetOrder = void 0;
+exports.LeaderboardOrder = exports.SortedSetOrder = void 0;
 var SortedSetOrder;
 (function (SortedSetOrder) {
     SortedSetOrder["Ascending"] = "ASC";
     SortedSetOrder["Descending"] = "DESC";
 })(SortedSetOrder = exports.SortedSetOrder || (exports.SortedSetOrder = {}));
-//# sourceMappingURL=data:application/json;base64,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
+var LeaderboardOrder;
+(function (LeaderboardOrder) {
+    LeaderboardOrder["Ascending"] = "ASC";
+    LeaderboardOrder["Descending"] = "DESC";
+})(LeaderboardOrder = exports.LeaderboardOrder || (exports.LeaderboardOrder = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-call-options.js","sourceRoot":"","sources":["../../../src/utils/cache-call-options.ts"],"names":[],"mappings":";;;AA8BA,IAAY,cAGX;AAHD,WAAY,cAAc;IACxB,mCAAiB,CAAA;IACjB,qCAAmB,CAAA;AACrB,CAAC,EAHW,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAGzB;AA0FD,IAAY,gBAGX;AAHD,WAAY,gBAAgB;IAC1B,qCAAiB,CAAA;IACjB,uCAAmB,CAAA;AACrB,CAAC,EAHW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAG3B","sourcesContent":["import {CollectionTtl} from './collection-ttl';\n\nexport interface ScalarCallOptions {\n  /**\n   * The time to live in seconds of the object being modified.\n   */\n  ttl?: number;\n}\n\nexport interface CollectionCallOptions {\n  /**\n   * The length of the TTL and whether it should be refreshed when the collection is modified.\n   */\n  ttl?: CollectionTtl;\n}\n\nexport interface FrontTruncatableCallOptions extends CollectionCallOptions {\n  /**\n   * If the collection exceeds this length, remove excess from the start of the list. Must be positive.\n   */\n  truncateFrontToSize?: number;\n}\n\nexport interface BackTruncatableCallOptions extends CollectionCallOptions {\n  /**\n   * If the collection exceeds this length, remove excess from the end of the list. Must be positive.\n   */\n  truncateBackToSize?: number;\n}\n\nexport enum SortedSetOrder {\n  Ascending = 'ASC',\n  Descending = 'DESC',\n}\n\nexport interface SortedSetFetchByRankCallOptions {\n  /**\n   * The rank of the first element to return, inclusive.\n   * If negative, the rank is relative to the end of the list.\n   * If the rank is not specified, the first element is used.\n   */\n  startRank?: number;\n  /**\n   * The rank of the last element to return, exclusive.\n   * If negative, the rank is relative to the end of the list.\n   * If the rank is not specified, the range extends to the end of the list.\n   */\n  endRank?: number;\n  /**\n   * The order in which to return the elements.\n   * If the order is not specified, the elements are returned in ascending order.\n   * If descending order is used, the start and end ranks are interpreted as if\n   * the list were reversed.\n   */\n  order?: SortedSetOrder;\n}\n\nexport interface SortedSetFetchByScoreCallOptions {\n  /**\n   * The minimum score of the elements to return, inclusive.\n   * If the minimum score is not specified, the range extends to the lowest score.\n   */\n  minScore?: number;\n  /**\n   * The maximum score of the elements to return, inclusive.\n   * If the maximum score is not specified, the range extends to the highest score.\n   */\n  maxScore?: number;\n  /**\n   * The order in which to return the elements.\n   * If the order is not specified, the elements are returned in ascending order.\n   */\n  order?: SortedSetOrder;\n  /**\n   * The index offset of the first element to return, relative to the first element in the result set.\n   * If specified must be non-negative (>= 0).\n   * Defaults to zero, ie. the start at first element in the result set.\n   */\n  offset?: number;\n  /**\n   * The maximum number of elements to return.\n   * If specified must be strictly positive (> 0).\n   * Defaults to all elements in the result set.\n   */\n  count?: number;\n}\n\nexport interface SortedSetLengthByScoreCallOptions {\n  /**\n   * The minimum score of the elements to include when counting number of items in the set, inclusive.\n   * If the minimum score is not specified, the range extends to the lowest score.\n   */\n  minScore?: number;\n  /**\n   * The maximum score of the elements to include when counting number of items in the set, inclusive.\n   * If the maximum score is not specified, the range extends to the highest score.\n   */\n  maxScore?: number;\n}\n\nexport interface ListRetainCallOptions extends CollectionCallOptions {\n  /**\n   * Starting inclusive index of operation.\n   */\n  startIndex?: number;\n\n  /**\n   * Ending exclusive index of operation.\n   */\n  endIndex?: number;\n}\nexport interface ListFetchCallOptions {\n  /**\n   * Starting inclusive index of operation.\n   */\n  startIndex?: number;\n\n  /**\n   * Ending exclusive index of operation.\n   */\n  endIndex?: number;\n}\n\nexport enum LeaderboardOrder {\n  Ascending = 'ASC', // 0 is the lowest-scoring rank\n  Descending = 'DESC', // 0 is the highest-scoring rank.\n}\n\nexport interface LeaderboardGetRankCallOptions {\n  /**\n   * The order in which to return the elements.\n   * If the order is not specified, the elements are returned in ascending order.\n   * If descending order is used, the start and end ranks are interpreted as if\n   * the leaderboard were reversed.\n   */\n  order?: LeaderboardOrder;\n}\n\nexport interface LeaderboardFetchByRankCallOptions {\n  /**\n   * The rank of the first element to return, inclusive.\n   * If the rank is not specified, defaults to 0.\n   * Ranks can be used to manually paginate through the leaderboard\n   * in batches of 8192 elements (e.g. request 0-8192, then 8192-16384, etc)\n   */\n  startRank?: number;\n  /**\n   * The rank of the last element to return, exclusive.\n   * If the rank is not specified, defaults to 8192.\n   * Ranks can be used to manually paginate through the leaderboard\n   * in batches of 8192 elements (e.g. request 0-8192, then 8192-16384, etc)\n   */\n  endRank?: number;\n  /**\n   * The order in which to return the elements.\n   * If the order is not specified, the elements are returned in ascending order.\n   * If descending order is used, the start and end ranks are interpreted as if\n   * the leaderboard were reversed.\n   */\n  order?: LeaderboardOrder;\n}\n\nexport interface LeaderboardFetchByScoreCallOptions {\n  /**\n   * The minimum score of the elements to return, inclusive.\n   * If the minimum score is not specified, the range extends to the lowest score.\n   */\n  minScore?: number;\n  /**\n   * The maximum score of the elements to return, exclusive.\n   * If the maximum score is not specified, the range extends to the highest score.\n   */\n  maxScore?: number;\n  /**\n   * The order in which to return the elements.\n   * If the order is not specified, the elements are returned in ascending order.\n   */\n  order?: LeaderboardOrder;\n  /**\n   * The index offset of the first element to return, relative to the first element in the result set.\n   * If specified must be non-negative (>= 0).\n   * Defaults to zero, ie. the start at first element in the result set.\n   */\n  offset?: number;\n  /**\n   * The maximum number of elements to return.\n   * If specified must be strictly positive (> 0).\n   * Defaults to 8192, the maximum number of elements that can be returned at a time.\n   */\n  count?: number;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gomomento/sdk-core",
-  "version": "1.41.2",
+  "version": "1.42.1",
   "description": "Common code for Momento JS SDKs",
   "main": "dist/src/index.js",
   "files": [