@gomomento/sdk-core 1.12.8

package/dist/src/messages/responses/cache-dictionary-get-field.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Error = exports.Miss = exports.Hit = exports.Response = void 0;
+const response_base_1 = require("./response-base");
+const display_1 = require("../../internal/utils/display");
+const TEXT_DECODER = new TextDecoder();
+/**
+ * Parent response type for a dictionary get field request.  The
+ * response object is resolved to a type-safe object of one of
+ * the following subtypes:
+ *
+ * - {Hit}
+ * - {Miss}
+ * - {Error}
+ *
+ * `instanceof` type guards can be used to operate on the appropriate subtype.
+ * @example
+ * For example:
+ * ```
+ * if (response instanceof CacheDictionaryGetField.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `CacheDictionaryGetField.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 _Hit extends Response {
+    constructor(body) {
+        super();
+        this.body = body;
+    }
+    /**
+     * Returns the data as a utf-8 string, decoded from the underlying byte array.
+     * @returns string
+     */
+    valueString() {
+        return TEXT_DECODER.decode(this.body);
+    }
+    /**
+     * Returns the data as a byte array.
+     * @returns {Uint8Array}
+     */
+    valueUint8Array() {
+        return this.body;
+    }
+    toString() {
+        const display = (0, display_1.truncateString)(this.valueString());
+        return `${super.toString()}: ${display}`;
+    }
+}
+/**
+ * Indicates that the requested data was successfully retrieved from the cache.  Provides
+ * `value*` accessors to retrieve the data in the appropriate format.
+ */
+class Hit extends (0, response_base_1.ResponseHit)(_Hit) {
+    constructor(body, field) {
+        super(body);
+        this.field = field;
+    }
+    /**
+     * Returns the field name for the retrieved element, as a utf-8 string decoded from the underlying byte array.
+     * @returns {string}
+     */
+    fieldString() {
+        return TEXT_DECODER.decode(this.field);
+    }
+    /**
+     * Returns the field name for the retrieved element, as a byte array.
+     * @returns {Uint8Array}
+     */
+    fieldUint8Array() {
+        return this.field;
+    }
+}
+exports.Hit = Hit;
+class _Miss extends Response {
+}
+/**
+ * Indicates that the requested data was not available in the cache.
+ */
+class Miss extends (0, response_base_1.ResponseMiss)(_Miss) {
+    constructor(field) {
+        super();
+        this.field = field;
+    }
+    /**
+     * Returns the field name for the retrieved element, as a utf-8 string decoded from the underlying byte array.
+     * @returns {string}
+     */
+    fieldString() {
+        return TEXT_DECODER.decode(this.field);
+    }
+    /**
+     * Returns the field name for the retrieved element, as a byte array.
+     * @returns {Uint8Array}
+     */
+    fieldUint8Array() {
+        return this.field;
+    }
+}
+exports.Miss = Miss;
+class _Error extends Response {
+    constructor(_innerException) {
+        super();
+        this._innerException = _innerException;
+    }
+}
+/**
+ * Indicates that an error occurred during the dictionary get field 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) {
+    constructor(_innerException, field) {
+        super(_innerException);
+        this._innerException = _innerException;
+        this.field = field;
+    }
+    /**
+     * Returns the field name for the retrieved element, as a utf-8 string decoded from the underlying byte array.
+     * @returns {string}
+     */
+    fieldString() {
+        return TEXT_DECODER.decode(this.field);
+    }
+    /**
+     * Returns the field name for the retrieved element, as a byte array.
+     * @returns {Uint8Array}
+     */
+    fieldUint8Array() {
+        return this.field;
+    }
+}
+exports.Error = Error;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-dictionary-get-field.js","sourceRoot":"","sources":["../../../../src/messages/responses/cache-dictionary-get-field.ts"],"names":[],"mappings":";;;AACA,mDAKyB;AACzB,0DAA4D;AAE5D,MAAM,YAAY,GAAG,IAAI,WAAW,EAAE,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAsB,QAAS,SAAQ,4BAAY;CAAG;AAAtD,4BAAsD;AAEtD,MAAM,IAAK,SAAQ,QAAQ;IAEzB,YAAY,IAAgB;QAC1B,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IACD;;;OAGG;IACI,WAAW;QAChB,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IAED;;;OAGG;IACI,eAAe;QACpB,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAEe,QAAQ;QACtB,MAAM,OAAO,GAAG,IAAA,wBAAc,EAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;QACnD,OAAO,GAAG,KAAK,CAAC,QAAQ,EAAE,KAAK,OAAO,EAAE,CAAC;IAC3C,CAAC;CACF;AAED;;;GAGG;AACH,MAAa,GAAI,SAAQ,IAAA,2BAAW,EAAC,IAAI,CAAC;IAGxC,YAAY,IAAgB,EAAE,KAAiB;QAC7C,KAAK,CAAC,IAAI,CAAC,CAAC;QACZ,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;;OAGG;IACI,WAAW;QAChB,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED;;;OAGG;IACI,eAAe;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;CACF;AAvBD,kBAuBC;AAED,MAAM,KAAM,SAAQ,QAAQ;CAAG;AAE/B;;GAEG;AACH,MAAa,IAAK,SAAQ,IAAA,4BAAY,EAAC,KAAK,CAAC;IAG3C,YAAY,KAAiB;QAC3B,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;;OAGG;IACI,WAAW;QAChB,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED;;;OAGG;IACI,eAAe;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;CACF;AAvBD,oBAuBC;AAED,MAAM,MAAO,SAAQ,QAAQ;IAC3B,YAAsB,eAAyB;QAC7C,KAAK,EAAE,CAAC;QADY,oBAAe,GAAf,eAAe,CAAU;IAE/C,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAa,KAAM,SAAQ,IAAA,6BAAa,EAAC,MAAM,CAAC;IAG9C,YAAmB,eAAyB,EAAE,KAAiB;QAC7D,KAAK,CAAC,eAAe,CAAC,CAAC;QADN,oBAAe,GAAf,eAAe,CAAU;QAE1C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;;OAGG;IACI,WAAW;QAChB,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED;;;OAGG;IACI,eAAe;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;CACF;AAvBD,sBAuBC","sourcesContent":["import {SdkError} from '../../errors/errors';\nimport {\n  ResponseBase,\n  ResponseError,\n  ResponseHit,\n  ResponseMiss,\n} from './response-base';\nimport {truncateString} from '../../internal/utils/display';\n\nconst TEXT_DECODER = new TextDecoder();\n\n/**\n * Parent response type for a dictionary get field request.  The\n * response object is resolved to a type-safe object of one of\n * the following subtypes:\n *\n * - {Hit}\n * - {Miss}\n * - {Error}\n *\n * `instanceof` type guards can be used to operate on the appropriate subtype.\n * @example\n * For example:\n * ```\n * if (response instanceof CacheDictionaryGetField.Error) {\n *   // Handle error as appropriate.  The compiler will smart-cast `response` to type\n *   // `CacheDictionaryGetField.Error` in this block, so you will have access to the properties\n *   // of the Error class; e.g. `response.errorCode()`.\n * }\n * ```\n */\nexport abstract class Response extends ResponseBase {}\n\nclass _Hit extends Response {\n  private readonly body: Uint8Array;\n  constructor(body: Uint8Array) {\n    super();\n    this.body = body;\n  }\n  /**\n   * Returns the data as a utf-8 string, decoded from the underlying byte array.\n   * @returns string\n   */\n  public valueString(): string {\n    return TEXT_DECODER.decode(this.body);\n  }\n\n  /**\n   * Returns the data as a byte array.\n   * @returns {Uint8Array}\n   */\n  public valueUint8Array(): Uint8Array {\n    return this.body;\n  }\n\n  public override toString(): string {\n    const display = truncateString(this.valueString());\n    return `${super.toString()}: ${display}`;\n  }\n}\n\n/**\n * Indicates that the requested data was successfully retrieved from the cache.  Provides\n * `value*` accessors to retrieve the data in the appropriate format.\n */\nexport class Hit extends ResponseHit(_Hit) {\n  private readonly field: Uint8Array;\n\n  constructor(body: Uint8Array, field: Uint8Array) {\n    super(body);\n    this.field = field;\n  }\n\n  /**\n   * Returns the field name for the retrieved element, as a utf-8 string decoded from the underlying byte array.\n   * @returns {string}\n   */\n  public fieldString(): string {\n    return TEXT_DECODER.decode(this.field);\n  }\n\n  /**\n   * Returns the field name for the retrieved element, as a byte array.\n   * @returns {Uint8Array}\n   */\n  public fieldUint8Array(): Uint8Array {\n    return this.field;\n  }\n}\n\nclass _Miss extends Response {}\n\n/**\n * Indicates that the requested data was not available in the cache.\n */\nexport class Miss extends ResponseMiss(_Miss) {\n  private readonly field: Uint8Array;\n\n  constructor(field: Uint8Array) {\n    super();\n    this.field = field;\n  }\n\n  /**\n   * Returns the field name for the retrieved element, as a utf-8 string decoded from the underlying byte array.\n   * @returns {string}\n   */\n  public fieldString(): string {\n    return TEXT_DECODER.decode(this.field);\n  }\n\n  /**\n   * Returns the field name for the retrieved element, as a byte array.\n   * @returns {Uint8Array}\n   */\n  public fieldUint8Array(): Uint8Array {\n    return this.field;\n  }\n}\n\nclass _Error extends Response {\n  constructor(protected _innerException: SdkError) {\n    super();\n  }\n}\n\n/**\n * Indicates that an error occurred during the dictionary get field request.\n *\n * This response object includes the following fields that you can use to determine\n * how you would like to handle the error:\n *\n * - `errorCode()` - a unique Momento error code indicating the type of error that occurred.\n * - `message()` - a human-readable description of the error\n * - `innerException()` - the original error that caused the failure; can be re-thrown.\n */\nexport class Error extends ResponseError(_Error) {\n  private readonly field: Uint8Array;\n\n  constructor(public _innerException: SdkError, field: Uint8Array) {\n    super(_innerException);\n    this.field = field;\n  }\n\n  /**\n   * Returns the field name for the retrieved element, as a utf-8 string decoded from the underlying byte array.\n   * @returns {string}\n   */\n  public fieldString(): string {\n    return TEXT_DECODER.decode(this.field);\n  }\n\n  /**\n   * Returns the field name for the retrieved element, as a byte array.\n   * @returns {Uint8Array}\n   */\n  public fieldUint8Array(): Uint8Array {\n    return this.field;\n  }\n}\n"]}

package/dist/src/messages/responses/cache-dictionary-get-fields.d.ts

@@ -0,0 +1,122 @@
+import { SdkError } from '../../errors/errors';
+import { ResponseBase } from './response-base';
+import * as CacheDictionaryGetFieldResponse from './cache-dictionary-get-field';
+import { _DictionaryGetResponsePart } from './grpc-response-types';
+type CacheDictionaryGetFieldResponseType = CacheDictionaryGetFieldResponse.Hit | CacheDictionaryGetFieldResponse.Miss | CacheDictionaryGetFieldResponse.Error;
+/**
+ * Parent response type for a dictionary get fields request.  The
+ * response object is resolved to a type-safe object of one of
+ * the following subtypes:
+ *
+ * - {Hit}
+ * - {Miss}
+ * - {Error}
+ *
+ * `instanceof` type guards can be used to operate on the appropriate subtype.
+ * @example
+ * For example:
+ * ```
+ * if (response instanceof CacheDictionaryGetFields.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `CacheDictionaryGetFields.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 _Hit extends Response {
+    private readonly items;
+    private readonly fields;
+    responses: CacheDictionaryGetFieldResponseType[];
+    constructor(items: _DictionaryGetResponsePart[], fields: Uint8Array[]);
+    /**
+     * Returns the data as a Map whose keys and values are byte arrays.
+     * @returns {Map<Uint8Array, Uint8Array>}
+     */
+    valueMapUint8ArrayUint8Array(): Map<Uint8Array, Uint8Array>;
+    /**
+     * Returns the data as a Map whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * @returns {Map<string, string>}
+     */
+    valueMapStringString(): Map<string, string>;
+    /**
+     * Returns the data as a Map whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * This is a convenience alias for {valueMapStringString}.
+     * @returns {Map<string, string>}
+     */
+    valueMap(): Map<string, string>;
+    /**
+     * Returns the data as a Map whose keys are utf-8 strings, decoded from the underlying byte array, and whose values
+     * are byte arrays.
+     * @returns {Map<string, Uint8Array>}
+     */
+    valueMapStringUint8Array(): Map<string, Uint8Array>;
+    /**
+     * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * This can be used in most places where an Object is desired.
+     * @returns {Record<string, string>}
+     */
+    valueRecordStringString(): Record<string, string>;
+    /**
+     * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * This can be used in most places where an Object is desired.  This is a convenience alias for
+     * {valueRecordStringString}.
+     * @returns {Record<string, string>}
+     */
+    valueRecord(): Record<string, string>;
+    /**
+     * Returns the data as a Record whose keys are utf-8 strings, decoded from the underlying byte array, and whose
+     * values are byte arrays.  This can be used in most places where an Object is desired.
+     * @returns {Record<string, Uint8Array>}
+     */
+    valueRecordStringUint8Array(): Record<string, Uint8Array>;
+    toString(): string;
+}
+declare const Hit_base: {
+    new (...args: any[]): {};
+} & typeof _Hit;
+/**
+ * Indicates that the requested data was successfully retrieved from the cache.  Provides
+ * `value*` accessors to retrieve the data in the appropriate format.
+ */
+export declare class Hit extends Hit_base {
+}
+declare class _Miss extends Response {
+}
+declare const Miss_base: {
+    new (...args: any[]): {
+        readonly is_miss: boolean;
+    };
+} & typeof _Miss;
+/**
+ * Indicates that the requested data was not available in the cache.
+ */
+export declare class Miss extends Miss_base {
+}
+declare class _Error extends Response {
+    _innerException: SdkError;
+    constructor(_innerException: SdkError);
+}
+declare const Error_base: {
+    new (...args: any[]): {
+        _innerException: SdkError;
+        message(): string;
+        innerException(): SdkError;
+        errorCode(): import("../../errors/errors").MomentoErrorCode;
+        toString(): string;
+    };
+} & typeof _Error;
+/**
+ * Indicates that an error occurred during the dictionary get fields 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/cache-dictionary-get-fields.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Error = exports.Miss = exports.Hit = exports.Response = void 0;
+const errors_1 = require("../../errors/errors");
+const response_base_1 = require("./response-base");
+const CacheDictionaryGetFieldResponse = require("./cache-dictionary-get-field");
+const grpc_response_types_1 = require("./grpc-response-types");
+const TEXT_DECODER = new TextDecoder();
+/**
+ * Parent response type for a dictionary get fields request.  The
+ * response object is resolved to a type-safe object of one of
+ * the following subtypes:
+ *
+ * - {Hit}
+ * - {Miss}
+ * - {Error}
+ *
+ * `instanceof` type guards can be used to operate on the appropriate subtype.
+ * @example
+ * For example:
+ * ```
+ * if (response instanceof CacheDictionaryGetFields.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `CacheDictionaryGetFields.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 _Hit extends Response {
+    constructor(items, fields) {
+        super();
+        this.responses = [];
+        this.items = items;
+        this.fields = fields;
+        items.forEach((item, index) => {
+            if (item.result === grpc_response_types_1._ECacheResult.Hit) {
+                this.responses.push(new CacheDictionaryGetFieldResponse.Hit(item.cacheBody, fields[index]));
+            }
+            else if (item.result === grpc_response_types_1._ECacheResult.Miss) {
+                this.responses.push(new CacheDictionaryGetFieldResponse.Miss(fields[index]));
+            }
+            else {
+                this.responses.push(new CacheDictionaryGetFieldResponse.Error(new errors_1.UnknownError(item.result.toString()), fields[index]));
+            }
+        });
+    }
+    /**
+     * Returns the data as a Map whose keys and values are byte arrays.
+     * @returns {Map<Uint8Array, Uint8Array>}
+     */
+    valueMapUint8ArrayUint8Array() {
+        return this.items.reduce((acc, item, index) => {
+            if (item.result === grpc_response_types_1._ECacheResult.Hit) {
+                acc.set(this.fields[index], item.cacheBody);
+            }
+            return acc;
+        }, new Map());
+    }
+    /**
+     * Returns the data as a Map whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * @returns {Map<string, string>}
+     */
+    valueMapStringString() {
+        return this.items.reduce((acc, item, index) => {
+            if (item.result === grpc_response_types_1._ECacheResult.Hit) {
+                acc.set(TEXT_DECODER.decode(this.fields[index]), TEXT_DECODER.decode(item.cacheBody));
+            }
+            return acc;
+        }, new Map());
+    }
+    /**
+     * Returns the data as a Map whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * This is a convenience alias for {valueMapStringString}.
+     * @returns {Map<string, string>}
+     */
+    valueMap() {
+        return this.valueMapStringString();
+    }
+    /**
+     * Returns the data as a Map whose keys are utf-8 strings, decoded from the underlying byte array, and whose values
+     * are byte arrays.
+     * @returns {Map<string, Uint8Array>}
+     */
+    valueMapStringUint8Array() {
+        return this.items.reduce((acc, item, index) => {
+            if (item.result === grpc_response_types_1._ECacheResult.Hit) {
+                acc.set(TEXT_DECODER.decode(this.fields[index]), item.cacheBody);
+            }
+            return acc;
+        }, new Map());
+    }
+    /**
+     * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * This can be used in most places where an Object is desired.
+     * @returns {Record<string, string>}
+     */
+    valueRecordStringString() {
+        return this.items.reduce((acc, item, index) => {
+            if (item.result === grpc_response_types_1._ECacheResult.Hit) {
+                acc[TEXT_DECODER.decode(this.fields[index])] = TEXT_DECODER.decode(item.cacheBody);
+            }
+            return acc;
+        }, {});
+    }
+    /**
+     * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * This can be used in most places where an Object is desired.  This is a convenience alias for
+     * {valueRecordStringString}.
+     * @returns {Record<string, string>}
+     */
+    valueRecord() {
+        return this.valueRecordStringString();
+    }
+    /**
+     * Returns the data as a Record whose keys are utf-8 strings, decoded from the underlying byte array, and whose
+     * values are byte arrays.  This can be used in most places where an Object is desired.
+     * @returns {Record<string, Uint8Array>}
+     */
+    valueRecordStringUint8Array() {
+        return this.items.reduce((acc, item, index) => {
+            if (item.result === grpc_response_types_1._ECacheResult.Hit) {
+                acc[TEXT_DECODER.decode(this.fields[index])] = item.cacheBody;
+            }
+            return acc;
+        }, {});
+    }
+    toString() {
+        let stringRepresentation = '';
+        this.valueMapStringString().forEach((value, key) => {
+            const keyValue = `${key}: ${value}, `;
+            stringRepresentation = stringRepresentation + keyValue;
+        });
+        return `${super.toString()}: valueDictionaryStringString: ${stringRepresentation.slice(0, -2)}`;
+    }
+}
+/**
+ * Indicates that the requested data was successfully retrieved from the cache.  Provides
+ * `value*` accessors to retrieve the data in the appropriate format.
+ */
+class Hit extends (0, response_base_1.ResponseHit)(_Hit) {
+}
+exports.Hit = Hit;
+class _Miss extends Response {
+}
+/**
+ * Indicates that the requested data was not available in the cache.
+ */
+class Miss extends (0, response_base_1.ResponseMiss)(_Miss) {
+}
+exports.Miss = Miss;
+class _Error extends Response {
+    constructor(_innerException) {
+        super();
+        this._innerException = _innerException;
+    }
+}
+/**
+ * Indicates that an error occurred during the dictionary get fields 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,{"version":3,"file":"cache-dictionary-get-fields.js","sourceRoot":"","sources":["../../../../src/messages/responses/cache-dictionary-get-fields.ts"],"names":[],"mappings":"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","sourcesContent":["import {SdkError, UnknownError} from '../../errors/errors';\nimport {\n  ResponseBase,\n  ResponseHit,\n  ResponseMiss,\n  ResponseError,\n} from './response-base';\nimport * as CacheDictionaryGetFieldResponse from './cache-dictionary-get-field';\nimport {_DictionaryGetResponsePart, _ECacheResult} from './grpc-response-types';\n\nconst TEXT_DECODER = new TextDecoder();\ntype CacheDictionaryGetFieldResponseType =\n  | CacheDictionaryGetFieldResponse.Hit\n  | CacheDictionaryGetFieldResponse.Miss\n  | CacheDictionaryGetFieldResponse.Error;\n\n/**\n * Parent response type for a dictionary get fields request.  The\n * response object is resolved to a type-safe object of one of\n * the following subtypes:\n *\n * - {Hit}\n * - {Miss}\n * - {Error}\n *\n * `instanceof` type guards can be used to operate on the appropriate subtype.\n * @example\n * For example:\n * ```\n * if (response instanceof CacheDictionaryGetFields.Error) {\n *   // Handle error as appropriate.  The compiler will smart-cast `response` to type\n *   // `CacheDictionaryGetFields.Error` in this block, so you will have access to the properties\n *   // of the Error class; e.g. `response.errorCode()`.\n * }\n * ```\n */\nexport abstract class Response extends ResponseBase {}\n\nclass _Hit extends Response {\n  private readonly items: _DictionaryGetResponsePart[];\n  private readonly fields: Uint8Array[];\n  public responses: CacheDictionaryGetFieldResponseType[] = [];\n\n  constructor(items: _DictionaryGetResponsePart[], fields: Uint8Array[]) {\n    super();\n    this.items = items;\n    this.fields = fields;\n\n    items.forEach((item, index) => {\n      if (item.result === _ECacheResult.Hit) {\n        this.responses.push(\n          new CacheDictionaryGetFieldResponse.Hit(item.cacheBody, fields[index])\n        );\n      } else if (item.result === _ECacheResult.Miss) {\n        this.responses.push(\n          new CacheDictionaryGetFieldResponse.Miss(fields[index])\n        );\n      } else {\n        this.responses.push(\n          new CacheDictionaryGetFieldResponse.Error(\n            new UnknownError(item.result.toString()),\n            fields[index]\n          )\n        );\n      }\n    });\n  }\n\n  /**\n   * Returns the data as a Map whose keys and values are byte arrays.\n   * @returns {Map<Uint8Array, Uint8Array>}\n   */\n  public valueMapUint8ArrayUint8Array(): Map<Uint8Array, Uint8Array> {\n    return this.items.reduce((acc, item, index) => {\n      if (item.result === _ECacheResult.Hit) {\n        acc.set(this.fields[index], item.cacheBody);\n      }\n      return acc;\n    }, new Map<Uint8Array, Uint8Array>());\n  }\n\n  /**\n   * Returns the data as a Map whose keys and values are utf-8 strings, decoded from the underlying byte arrays.\n   * @returns {Map<string, string>}\n   */\n  public valueMapStringString(): Map<string, string> {\n    return this.items.reduce((acc, item, index) => {\n      if (item.result === _ECacheResult.Hit) {\n        acc.set(\n          TEXT_DECODER.decode(this.fields[index]),\n          TEXT_DECODER.decode(item.cacheBody)\n        );\n      }\n      return acc;\n    }, new Map<string, string>());\n  }\n\n  /**\n   * Returns the data as a Map whose keys and values are utf-8 strings, decoded from the underlying byte arrays.\n   * This is a convenience alias for {valueMapStringString}.\n   * @returns {Map<string, string>}\n   */\n  public valueMap(): Map<string, string> {\n    return this.valueMapStringString();\n  }\n\n  /**\n   * Returns the data as a Map whose keys are utf-8 strings, decoded from the underlying byte array, and whose values\n   * are byte arrays.\n   * @returns {Map<string, Uint8Array>}\n   */\n  public valueMapStringUint8Array(): Map<string, Uint8Array> {\n    return this.items.reduce((acc, item, index) => {\n      if (item.result === _ECacheResult.Hit) {\n        acc.set(TEXT_DECODER.decode(this.fields[index]), item.cacheBody);\n      }\n      return acc;\n    }, new Map<string, Uint8Array>());\n  }\n\n  /**\n   * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.\n   * This can be used in most places where an Object is desired.\n   * @returns {Record<string, string>}\n   */\n  public valueRecordStringString(): Record<string, string> {\n    return this.items.reduce<Record<string, string>>((acc, item, index) => {\n      if (item.result === _ECacheResult.Hit) {\n        acc[TEXT_DECODER.decode(this.fields[index])] = TEXT_DECODER.decode(\n          item.cacheBody\n        );\n      }\n      return acc;\n    }, {});\n  }\n\n  /**\n   * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.\n   * This can be used in most places where an Object is desired.  This is a convenience alias for\n   * {valueRecordStringString}.\n   * @returns {Record<string, string>}\n   */\n  public valueRecord(): Record<string, string> {\n    return this.valueRecordStringString();\n  }\n\n  /**\n   * Returns the data as a Record whose keys are utf-8 strings, decoded from the underlying byte array, and whose\n   * values are byte arrays.  This can be used in most places where an Object is desired.\n   * @returns {Record<string, Uint8Array>}\n   */\n  public valueRecordStringUint8Array(): Record<string, Uint8Array> {\n    return this.items.reduce<Record<string, Uint8Array>>((acc, item, index) => {\n      if (item.result === _ECacheResult.Hit) {\n        acc[TEXT_DECODER.decode(this.fields[index])] = item.cacheBody;\n      }\n      return acc;\n    }, {});\n  }\n\n  public override toString(): string {\n    let stringRepresentation = '';\n    this.valueMapStringString().forEach((value, key) => {\n      const keyValue = `${key}: ${value}, `;\n      stringRepresentation = stringRepresentation + keyValue;\n    });\n    return `${super.toString()}: valueDictionaryStringString: ${stringRepresentation.slice(\n      0,\n      -2\n    )}`;\n  }\n}\n\n/**\n * Indicates that the requested data was successfully retrieved from the cache.  Provides\n * `value*` accessors to retrieve the data in the appropriate format.\n */\nexport class Hit extends ResponseHit(_Hit) {}\n\nclass _Miss extends Response {}\n\n/**\n * Indicates that the requested data was not available in the cache.\n */\nexport class Miss extends ResponseMiss(_Miss) {}\n\nclass _Error extends Response {\n  constructor(public _innerException: SdkError) {\n    super();\n  }\n}\n\n/**\n * Indicates that an error occurred during the dictionary get fields request.\n *\n * This response object includes the following fields that you can use to determine\n * how you would like to handle the error:\n *\n * - `errorCode()` - a unique Momento error code indicating the type of error that occurred.\n * - `message()` - a human-readable description of the error\n * - `innerException()` - the original error that caused the failure; can be re-thrown.\n */\nexport class Error extends ResponseError(_Error) {}\n"]}

package/dist/src/messages/responses/cache-dictionary-increment.d.ts

@@ -0,0 +1,69 @@
+import { SdkError } from '../../errors/errors';
+import { ResponseBase } from './response-base';
+/**
+ * Parent response type for a dictionary increment 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 CacheDictionaryIncrement.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `CacheDictionaryIncrement.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 {
+    private readonly value;
+    constructor(value: number);
+    /**
+     * The new value of the element after incrementing.
+     * @returns {number}
+     */
+    valueNumber(): number;
+    toString(): string;
+}
+declare const Success_base: {
+    new (...args: any[]): {
+        readonly is_success: boolean;
+    };
+} & typeof _Success;
+/**
+ * Indicates a Successful dictionary increment 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/errors").MomentoErrorCode;
+        toString(): string;
+    };
+} & typeof _Error;
+/**
+ * Indicates that an error occurred during the dictionary increment 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/cache-dictionary-increment.js

@@ -0,0 +1,68 @@
+"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 dictionary increment 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 CacheDictionaryIncrement.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `CacheDictionaryIncrement.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 {
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    /**
+     * The new value of the element after incrementing.
+     * @returns {number}
+     */
+    valueNumber() {
+        return this.value;
+    }
+    toString() {
+        return `${super.toString()}: value: ${this.valueNumber()}`;
+    }
+}
+/**
+ * Indicates a Successful dictionary increment 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 dictionary increment 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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