@gomomento/sdk-core 1.115.1 → 1.117.0

package/dist/src/auth/credential-provider.d.ts

@@ -61,9 +61,21 @@ export declare abstract class CredentialProvider {
      * @returns {boolean} true if connecting to the endpoint connection with TLS; false if not using TLS
      */
     abstract isEndpointSecure(): boolean;
+    /**
+     * @deprecated use fromEnvVarV2() instead
+     */
     static fromEnvironmentVariable(props: EnvMomentoTokenProviderProps | string): CredentialProvider;
+    /**
+     * @deprecated use fromEnvVarV2() instead
+     */
     static fromEnvVar(props: EnvMomentoTokenProviderProps | string): CredentialProvider;
+    /**
+     * @deprecated use fromApiKeyV2() or fromDisposableToken() instead
+     */
     static fromString(props: StringMomentoTokenProviderProps | string): CredentialProvider;
+    static fromDisposableToken(props: StringMomentoTokenProviderProps | string): CredentialProvider;
+    static fromEnvVarV2(props?: EnvMomentoV2TokenProviderProps): CredentialProvider;
+    static fromApiKeyV2(props: ApiKeyV2TokenProviderProps): CredentialProvider;
     /**
      * Allow insecure connections to momento-local service for testing purposes.
      * Does not require a Momento API key.
@@ -98,10 +110,18 @@ export interface StringMomentoAuthTokenProviderProps extends CredentialProviderP
     authToken: string;
 }
 export type StringMomentoTokenProviderProps = StringMomentoApiKeyProviderProps | StringMomentoAuthTokenProviderProps;
+export type ApiKeyV2TokenProviderProps = StringMomentoTokenProviderProps & {
+    endpoint: string;
+};
+export interface EnvMomentoV2TokenProviderProps {
+    apiKeyEnvVar?: string;
+    endpointEnvVar?: string;
+}
 /**
  * Reads and parses a momento auth token stored in a String
  * @export
  * @class StringMomentoTokenProvider
+ * @deprecated use ApiKeyV2TokenProvider instead
  */
 export declare class StringMomentoTokenProvider extends CredentialProviderBase {
     private readonly apiKey;
@@ -133,6 +153,7 @@ export interface EnvMomentoTokenProviderProps extends CredentialProviderProps {
  * Reads and parses a momento auth token stored as an environment variable.
  * @export
  * @class EnvMomentoTokenProvider
+ * @deprecated use EnvMomentoV2TokenProvider instead
  */
 export declare class EnvMomentoTokenProvider extends StringMomentoTokenProvider {
     environmentVariableName: string;
@@ -170,4 +191,29 @@ export declare class MomentoLocalProvider implements CredentialProvider {
     isEndpointSecure(): boolean;
     withMomentoLocal(): CredentialProvider;
 }
+export declare class ApiKeyV2TokenProvider extends CredentialProviderBase {
+    private readonly apiKey;
+    private readonly allEndpoints;
+    /**
+     * @param {ApiKeyV2TokenProviderProps} props configuration options for the token provider
+     */
+    constructor(props: ApiKeyV2TokenProviderProps);
+    getAuthToken(): string;
+    getCacheEndpoint(): string;
+    isCacheEndpointSecure(): boolean;
+    getControlEndpoint(): string;
+    isControlEndpointSecure(): boolean;
+    getTokenEndpoint(): string;
+    isTokenEndpointSecure(): boolean;
+    isStorageEndpointSecure(): boolean;
+    areEndpointsOverridden(): boolean;
+    isEndpointSecure(): boolean;
+    withMomentoLocal(): CredentialProvider;
+}
+export declare class EnvMomentoV2TokenProvider extends ApiKeyV2TokenProvider {
+    /**
+     * @param {EnvMomentoV2TokenProviderProps} props configuration options for the token provider
+     */
+    constructor(props?: EnvMomentoV2TokenProviderProps);
+}
 export {};

package/dist/src/auth/credential-provider.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MomentoLocalProvider = exports.getDefaultCredentialProvider = exports.EnvMomentoTokenProvider = exports.StringMomentoTokenProvider = exports.CredentialProvider = void 0;
+exports.EnvMomentoV2TokenProvider = exports.ApiKeyV2TokenProvider = exports.MomentoLocalProvider = exports.getDefaultCredentialProvider = exports.EnvMomentoTokenProvider = exports.StringMomentoTokenProvider = exports.CredentialProvider = void 0;
 const utils_1 = require("../internal/utils");
 function isBaseEndpointOverride(endpointOverrides) {
     return endpointOverrides.baseEndpoint !== undefined;
@@ -18,15 +18,33 @@ function isAllEndpoints(endpointOverrides) {
  * @interface CredentialProvider
  */
 class CredentialProvider {
+    /**
+     * @deprecated use fromEnvVarV2() instead
+     */
     static fromEnvironmentVariable(props) {
         return new EnvMomentoTokenProvider(props);
     }
+    /**
+     * @deprecated use fromEnvVarV2() instead
+     */
     static fromEnvVar(props) {
         return new EnvMomentoTokenProvider(props);
     }
+    /**
+     * @deprecated use fromApiKeyV2() or fromDisposableToken() instead
+     */
     static fromString(props) {
         return new StringMomentoTokenProvider(props);
     }
+    static fromDisposableToken(props) {
+        return new StringMomentoTokenProvider(props);
+    }
+    static fromEnvVarV2(props) {
+        return new EnvMomentoV2TokenProvider(props);
+    }
+    static fromApiKeyV2(props) {
+        return new ApiKeyV2TokenProvider(props);
+    }
     /**
      * Allow insecure connections to momento-local service for testing purposes.
      * Does not require a Momento API key.
@@ -50,6 +68,7 @@ class CredentialProviderBase {
  * Reads and parses a momento auth token stored in a String
  * @export
  * @class StringMomentoTokenProvider
+ * @deprecated use ApiKeyV2TokenProvider instead
  */
 class StringMomentoTokenProvider extends CredentialProviderBase {
     /**
@@ -145,6 +164,7 @@ exports.StringMomentoTokenProvider = StringMomentoTokenProvider;
  * Reads and parses a momento auth token stored as an environment variable.
  * @export
  * @class EnvMomentoTokenProvider
+ * @deprecated use EnvMomentoV2TokenProvider instead
  */
 class EnvMomentoTokenProvider extends StringMomentoTokenProvider {
     /**
@@ -167,6 +187,7 @@ class EnvMomentoTokenProvider extends StringMomentoTokenProvider {
 }
 exports.EnvMomentoTokenProvider = EnvMomentoTokenProvider;
 function getDefaultCredentialProvider() {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
     return CredentialProvider.fromEnvVar('MOMENTO_API_KEY');
 }
 exports.getDefaultCredentialProvider = getDefaultCredentialProvider;
@@ -236,4 +257,112 @@ class MomentoLocalProvider {
     }
 }
 exports.MomentoLocalProvider = MomentoLocalProvider;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"credential-provider.js","sourceRoot":"","sources":["../../../src/auth/credential-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AllEndpoints,\n  decodeAuthToken,\n  fromEntries,\n  populateAllEndpointsFromBaseEndpoint,\n} from '../internal/utils';\n\nexport interface BaseEndpointOverride {\n  baseEndpoint: string;\n  endpointPrefix?: string;\n  secureConnection?: boolean;\n}\n\nexport type EndpointOverrides = BaseEndpointOverride | AllEndpoints;\n\nfunction isBaseEndpointOverride(\n  endpointOverrides: EndpointOverrides\n): endpointOverrides is BaseEndpointOverride {\n  return (endpointOverrides as BaseEndpointOverride).baseEndpoint !== undefined;\n}\n\nfunction isAllEndpoints(\n  endpointOverrides: EndpointOverrides\n): endpointOverrides is AllEndpoints {\n  const allEndpoints = endpointOverrides as AllEndpoints;\n  return (\n    allEndpoints.cacheEndpoint !== undefined &&\n    allEndpoints.controlEndpoint !== undefined &&\n    allEndpoints.tokenEndpoint !== undefined\n  );\n}\n\n/**\n * Encapsulates arguments for instantiating an EnvMomentoTokenProvider\n */\ninterface CredentialProviderProps {\n  endpointOverrides?: EndpointOverrides;\n}\n\n/**\n * Provides information that the CacheClient needs in order to establish a connection to and authenticate with\n * the Momento service.\n * @export\n * @interface CredentialProvider\n */\nexport abstract class CredentialProvider {\n  /**\n   * @returns {string} Auth token provided by user, required to authenticate with the service\n   */\n  abstract getAuthToken(): string;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento control plane operations\n   */\n  abstract getControlEndpoint(): string;\n\n  /**\n   * @deprecated use isEndpointSecure() instead\n   */\n  abstract isControlEndpointSecure(): boolean;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento data plane operations\n   */\n  abstract getCacheEndpoint(): string;\n\n  /**\n   * @deprecated use isEndpointSecure() instead\n   */\n  abstract isCacheEndpointSecure(): boolean;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento token operations\n   */\n  abstract getTokenEndpoint(): string;\n\n  /**\n   * @deprecated use isEndpointSecure() instead\n   */\n  abstract isTokenEndpointSecure(): boolean;\n\n  /**\n   * @deprecated - use the static method forMomentoLocal instead\n   *\n   * Modifies the instance of the credential provider to override endpoints to\n   * allow insecure connections to the momento-local service for testing purposes\n   */\n  abstract withMomentoLocal(): CredentialProvider;\n\n  /**\n   * @returns {boolean} true if the endpoints were manually overridden at construction time; false otherwise\n   */\n  abstract areEndpointsOverridden(): boolean;\n  /**\n   * @returns {boolean} true if connecting to the endpoint connection with TLS; false if not using TLS\n   */\n  abstract isEndpointSecure(): boolean;\n\n  static fromEnvironmentVariable(\n    props: EnvMomentoTokenProviderProps | string\n  ): CredentialProvider {\n    return new EnvMomentoTokenProvider(props);\n  }\n\n  static fromEnvVar(\n    props: EnvMomentoTokenProviderProps | string\n  ): CredentialProvider {\n    return new EnvMomentoTokenProvider(props);\n  }\n\n  static fromString(\n    props: StringMomentoTokenProviderProps | string\n  ): CredentialProvider {\n    return new StringMomentoTokenProvider(props);\n  }\n\n  /**\n   * Allow insecure connections to momento-local service for testing purposes.\n   * Does not require a Momento API key.\n   * @param props configuration options for connecting to momento-local\n   * @returns CredentialProvider\n   */\n  static forMomentoLocal(props: MomentoLocalProviderProps): CredentialProvider {\n    return new MomentoLocalProvider(props);\n  }\n}\n\nabstract class CredentialProviderBase implements CredentialProvider {\n  abstract getAuthToken(): string;\n\n  abstract getCacheEndpoint(): string;\n\n  abstract isCacheEndpointSecure(): boolean;\n\n  abstract getControlEndpoint(): string;\n\n  abstract isControlEndpointSecure(): boolean;\n\n  abstract getTokenEndpoint(): string;\n\n  abstract isTokenEndpointSecure(): boolean;\n\n  abstract areEndpointsOverridden(): boolean;\n\n  abstract isEndpointSecure(): boolean;\n\n  abstract withMomentoLocal(): CredentialProvider;\n\n  valueOf(): object {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    const entries = Object.entries(this).filter(([k]) => k !== 'authToken');\n    const clone = fromEntries(entries);\n    return clone.valueOf();\n  }\n}\n\nexport interface StringMomentoApiKeyProviderProps\n  extends CredentialProviderProps {\n  /**\n   * apiKey the momento API key\n   */\n  apiKey: string;\n}\n\nexport interface StringMomentoAuthTokenProviderProps\n  extends CredentialProviderProps {\n  /**\n   * authToken the momento auth token\n   */\n  authToken: string;\n}\n\nexport type StringMomentoTokenProviderProps =\n  | StringMomentoApiKeyProviderProps\n  | StringMomentoAuthTokenProviderProps;\n\n/**\n * Reads and parses a momento auth token stored in a String\n * @export\n * @class StringMomentoTokenProvider\n */\nexport class StringMomentoTokenProvider extends CredentialProviderBase {\n  private readonly apiKey: string;\n  private readonly allEndpoints: AllEndpoints;\n  private readonly endpointsOverridden: boolean;\n\n  /**\n   * @param {StringMomentoTokenProviderProps} props configuration options for the token provider\n   */\n  constructor(props: StringMomentoTokenProviderProps | string) {\n    if (typeof props === 'string') {\n      props = {apiKey: props};\n    }\n    super();\n    let key: string;\n    if ('authToken' in props) {\n      key = props.authToken;\n    } else if ('apiKey' in props) {\n      key = props.apiKey;\n    } else {\n      throw new Error('Missing required property: authToken or apiKey');\n    }\n    const decodedToken = decodeAuthToken(key);\n    this.apiKey = decodedToken.authToken;\n    if (props.endpointOverrides === undefined) {\n      this.endpointsOverridden = false;\n      if (decodedToken.controlEndpoint === undefined) {\n        throw new Error(\n          'Malformed token; unable to determine control endpoint.  Depending on the type of token you are using, you may need to specify the controlEndpoint explicitly.'\n        );\n      }\n      if (decodedToken.cacheEndpoint === undefined) {\n        throw new Error(\n          'Malformed token; unable to determine cache endpoint.  Depending on the type of token you are using, you may need to specify the cacheEndpoint explicitly.'\n        );\n      }\n      if (decodedToken.tokenEndpoint === undefined) {\n        throw new Error(\n          'Malformed token; unable to determine token endpoint.  Depending on the type of token you are using, you may need to specify the tokenEndpoint explicitly.'\n        );\n      }\n\n      this.allEndpoints = {\n        controlEndpoint: decodedToken.controlEndpoint,\n        cacheEndpoint: decodedToken.cacheEndpoint,\n        tokenEndpoint: decodedToken.tokenEndpoint,\n      };\n    } else if (isAllEndpoints(props.endpointOverrides)) {\n      this.endpointsOverridden = true;\n      this.allEndpoints = props.endpointOverrides;\n    } else if (isBaseEndpointOverride(props.endpointOverrides)) {\n      this.endpointsOverridden = true;\n      this.allEndpoints = populateAllEndpointsFromBaseEndpoint(\n        props.endpointOverrides\n      );\n    } else {\n      throw new Error(\n        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n        `Unsupported endpointOverrides: ${props.endpointOverrides}`\n      );\n    }\n  }\n\n  getAuthToken(): string {\n    return this.apiKey;\n  }\n\n  getCacheEndpoint(): string {\n    return this.allEndpoints.cacheEndpoint;\n  }\n  isCacheEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  getControlEndpoint(): string {\n    return this.allEndpoints.controlEndpoint;\n  }\n\n  isControlEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  getTokenEndpoint(): string {\n    return this.allEndpoints.tokenEndpoint;\n  }\n\n  isTokenEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  isStorageEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  areEndpointsOverridden(): boolean {\n    return this.endpointsOverridden;\n  }\n\n  isEndpointSecure(): boolean {\n    if (this.allEndpoints.secureConnection === undefined) {\n      return true;\n    }\n    return this.allEndpoints.secureConnection;\n  }\n\n  withMomentoLocal(): CredentialProvider {\n    return new MomentoLocalProvider();\n  }\n}\n\nexport interface EnvMomentoTokenProviderProps extends CredentialProviderProps {\n  /**\n   * the name of the environment variable from which the auth token will be read\n   */\n  environmentVariableName: string;\n}\n\n/**\n * Reads and parses a momento auth token stored as an environment variable.\n * @export\n * @class EnvMomentoTokenProvider\n */\nexport class EnvMomentoTokenProvider extends StringMomentoTokenProvider {\n  environmentVariableName: string;\n  /**\n   * @param {EnvMomentoTokenProviderProps} props configuration options for the token provider\n   */\n  constructor(props: EnvMomentoTokenProviderProps | string) {\n    if (typeof props === 'string') {\n      props = {environmentVariableName: props};\n    }\n    const authToken = process.env[props.environmentVariableName];\n    if (!authToken) {\n      throw new Error(\n        `Missing required environment variable ${props.environmentVariableName}`\n      );\n    }\n    super({\n      authToken: authToken,\n      endpointOverrides: props.endpointOverrides,\n    });\n    this.environmentVariableName = props.environmentVariableName;\n  }\n}\n\nexport function getDefaultCredentialProvider(): CredentialProvider {\n  return CredentialProvider.fromEnvVar('MOMENTO_API_KEY');\n}\n\nexport interface MomentoLocalProviderProps extends CredentialProviderProps {\n  /**\n   * The hostname of the momento-local service\n   */\n  hostname?: string;\n  /**\n   * The port of the momento-local service\n   */\n  port?: number;\n}\n\nexport class MomentoLocalProvider implements CredentialProvider {\n  private readonly allEndpoints: AllEndpoints;\n  private readonly endpointsOverridden: boolean;\n\n  /**\n   * @param {MomentoLocalProviderProps} props configuration options for connecting to momento-local\n   */\n  constructor(props?: MomentoLocalProviderProps) {\n    const hostname = props?.hostname || '127.0.0.1';\n    const port = props?.port || 8080;\n    const momentoLocalEndpoint = `${hostname}:${port}`;\n\n    if (props === undefined || props.endpointOverrides === undefined) {\n      this.endpointsOverridden = false;\n      this.allEndpoints = {\n        controlEndpoint: momentoLocalEndpoint,\n        cacheEndpoint: momentoLocalEndpoint,\n        tokenEndpoint: momentoLocalEndpoint,\n        secureConnection: false,\n      };\n    } else if (isAllEndpoints(props.endpointOverrides)) {\n      this.endpointsOverridden = true;\n      this.allEndpoints = props.endpointOverrides;\n    } else if (isBaseEndpointOverride(props.endpointOverrides)) {\n      this.endpointsOverridden = true;\n      this.allEndpoints = populateAllEndpointsFromBaseEndpoint(\n        props.endpointOverrides\n      );\n    } else {\n      throw new Error(\n        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n        `Unsupported endpointOverrides: ${props.endpointOverrides}`\n      );\n    }\n  }\n\n  getAuthToken(): string {\n    return '';\n  }\n\n  getCacheEndpoint(): string {\n    return this.allEndpoints.cacheEndpoint;\n  }\n\n  isCacheEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  getControlEndpoint(): string {\n    return this.allEndpoints.controlEndpoint;\n  }\n\n  isControlEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  getTokenEndpoint(): string {\n    return this.allEndpoints.tokenEndpoint;\n  }\n\n  isTokenEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  areEndpointsOverridden(): boolean {\n    return this.endpointsOverridden;\n  }\n\n  isEndpointSecure(): boolean {\n    if (this.allEndpoints.secureConnection === undefined) {\n      return true;\n    }\n    return this.allEndpoints.secureConnection;\n  }\n\n  withMomentoLocal(): CredentialProvider {\n    return new MomentoLocalProvider();\n  }\n}\n"]}
+class ApiKeyV2TokenProvider extends CredentialProviderBase {
+    /**
+     * @param {ApiKeyV2TokenProviderProps} props configuration options for the token provider
+     */
+    constructor(props) {
+        super();
+        let key;
+        if ('authToken' in props) {
+            key = props.authToken;
+        }
+        else if ('apiKey' in props) {
+            key = props.apiKey;
+        }
+        else {
+            throw new Error('Missing required property: authToken or apiKey');
+        }
+        if (!key.length) {
+            throw new Error('API key cannot be an empty string');
+        }
+        if (!(0, utils_1.isV2ApiKey)(key)) {
+            throw new Error('Received an invalid v2 API key. Are you using the correct key? Or did you mean to use `fromString()` with a legacy key instead?');
+        }
+        let endpoint;
+        if ('endpoint' in props) {
+            endpoint = props.endpoint;
+        }
+        else {
+            throw new Error('Missing required property: endpoint');
+        }
+        if (!endpoint.length) {
+            throw new Error('Endpoint cannot be an empty string');
+        }
+        this.apiKey = key;
+        this.allEndpoints = {
+            controlEndpoint: 'control.' + endpoint,
+            cacheEndpoint: 'cache.' + endpoint,
+            tokenEndpoint: 'token.' + endpoint,
+        };
+    }
+    getAuthToken() {
+        return this.apiKey;
+    }
+    getCacheEndpoint() {
+        return this.allEndpoints.cacheEndpoint;
+    }
+    isCacheEndpointSecure() {
+        return this.isEndpointSecure();
+    }
+    getControlEndpoint() {
+        return this.allEndpoints.controlEndpoint;
+    }
+    isControlEndpointSecure() {
+        return this.isEndpointSecure();
+    }
+    getTokenEndpoint() {
+        return this.allEndpoints.tokenEndpoint;
+    }
+    isTokenEndpointSecure() {
+        return this.isEndpointSecure();
+    }
+    isStorageEndpointSecure() {
+        return this.isEndpointSecure();
+    }
+    areEndpointsOverridden() {
+        return false;
+    }
+    isEndpointSecure() {
+        if (this.allEndpoints.secureConnection === undefined) {
+            return true;
+        }
+        return this.allEndpoints.secureConnection;
+    }
+    withMomentoLocal() {
+        return new MomentoLocalProvider();
+    }
+}
+exports.ApiKeyV2TokenProvider = ApiKeyV2TokenProvider;
+class EnvMomentoV2TokenProvider extends ApiKeyV2TokenProvider {
+    /**
+     * @param {EnvMomentoV2TokenProviderProps} props configuration options for the token provider
+     */
+    constructor(props) {
+        const apiKeyEnvVar = (props === null || props === void 0 ? void 0 : props.apiKeyEnvVar) || 'MOMENTO_API_KEY';
+        const endpointEnvVar = (props === null || props === void 0 ? void 0 : props.endpointEnvVar) || 'MOMENTO_ENDPOINT';
+        const endpoint = process.env[endpointEnvVar];
+        if (!endpoint) {
+            throw new Error(`Empty value for environment variable ${endpointEnvVar}`);
+        }
+        if (!endpoint.length) {
+            throw new Error(`Endpoint environment variable ${endpointEnvVar} cannot be an empty string`);
+        }
+        const authToken = process.env[apiKeyEnvVar];
+        if (!authToken) {
+            throw new Error(`Empty value for environment variable ${apiKeyEnvVar}`);
+        }
+        if (!authToken.length) {
+            throw new Error(`API key environment variable ${apiKeyEnvVar} cannot be an empty string`);
+        }
+        if (!(0, utils_1.isV2ApiKey)(authToken)) {
+            throw new Error('Received an invalid v2 API key. Are you using the correct key? Or did you mean to use `fromEnvironmentVariable()` with a legacy key instead?');
+        }
+        super({
+            authToken: authToken,
+            endpoint: endpoint,
+        });
+    }
+}
+exports.EnvMomentoV2TokenProvider = EnvMomentoV2TokenProvider;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"credential-provider.js","sourceRoot":"","sources":["../../../src/auth/credential-provider.ts"],"names":[],"mappings":";;;AAAA,6CAM2B;AAU3B,SAAS,sBAAsB,CAC7B,iBAAoC;IAEpC,OAAQ,iBAA0C,CAAC,YAAY,KAAK,SAAS,CAAC;AAChF,CAAC;AAED,SAAS,cAAc,CACrB,iBAAoC;IAEpC,MAAM,YAAY,GAAG,iBAAiC,CAAC;IACvD,OAAO,CACL,YAAY,CAAC,aAAa,KAAK,SAAS;QACxC,YAAY,CAAC,eAAe,KAAK,SAAS;QAC1C,YAAY,CAAC,aAAa,KAAK,SAAS,CACzC,CAAC;AACJ,CAAC;AASD;;;;;GAKG;AACH,MAAsB,kBAAkB;IAqDtC;;OAEG;IACH,MAAM,CAAC,uBAAuB,CAC5B,KAA4C;QAE5C,OAAO,IAAI,uBAAuB,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,UAAU,CACf,KAA4C;QAE5C,OAAO,IAAI,uBAAuB,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,UAAU,CACf,KAA+C;QAE/C,OAAO,IAAI,0BAA0B,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;IAED,MAAM,CAAC,mBAAmB,CACxB,KAA+C;QAE/C,OAAO,IAAI,0BAA0B,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;IAED,MAAM,CAAC,YAAY,CACjB,KAAsC;QAEtC,OAAO,IAAI,yBAAyB,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED,MAAM,CAAC,YAAY,CAAC,KAAiC;QACnD,OAAO,IAAI,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,eAAe,CAAC,KAAgC;QACrD,OAAO,IAAI,oBAAoB,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;CACF;AAzGD,gDAyGC;AAED,MAAe,sBAAsB;IAqBnC,OAAO;QACL,6DAA6D;QAC7D,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC;QACxE,MAAM,KAAK,GAAG,IAAA,mBAAW,EAAC,OAAO,CAAC,CAAC;QACnC,OAAO,KAAK,CAAC,OAAO,EAAE,CAAC;IACzB,CAAC;CACF;AA+BD;;;;;GAKG;AACH,MAAa,0BAA2B,SAAQ,sBAAsB;IAKpE;;OAEG;IACH,YAAY,KAA+C;QACzD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,KAAK,GAAG,EAAC,MAAM,EAAE,KAAK,EAAC,CAAC;SACzB;QACD,KAAK,EAAE,CAAC;QACR,IAAI,GAAW,CAAC;QAChB,IAAI,WAAW,IAAI,KAAK,EAAE;YACxB,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC;SACvB;aAAM,IAAI,QAAQ,IAAI,KAAK,EAAE;YAC5B,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC;SACpB;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;SACnE;QACD,MAAM,YAAY,GAAG,IAAA,uBAAe,EAAC,GAAG,CAAC,CAAC;QAC1C,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC,SAAS,CAAC;QACrC,IAAI,KAAK,CAAC,iBAAiB,KAAK,SAAS,EAAE;YACzC,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;YACjC,IAAI,YAAY,CAAC,eAAe,KAAK,SAAS,EAAE;gBAC9C,MAAM,IAAI,KAAK,CACb,+JAA+J,CAChK,CAAC;aACH;YACD,IAAI,YAAY,CAAC,aAAa,KAAK,SAAS,EAAE;gBAC5C,MAAM,IAAI,KAAK,CACb,2JAA2J,CAC5J,CAAC;aACH;YACD,IAAI,YAAY,CAAC,aAAa,KAAK,SAAS,EAAE;gBAC5C,MAAM,IAAI,KAAK,CACb,2JAA2J,CAC5J,CAAC;aACH;YAED,IAAI,CAAC,YAAY,GAAG;gBAClB,eAAe,EAAE,YAAY,CAAC,eAAe;gBAC7C,aAAa,EAAE,YAAY,CAAC,aAAa;gBACzC,aAAa,EAAE,YAAY,CAAC,aAAa;aAC1C,CAAC;SACH;aAAM,IAAI,cAAc,CAAC,KAAK,CAAC,iBAAiB,CAAC,EAAE;YAClD,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,iBAAiB,CAAC;SAC7C;aAAM,IAAI,sBAAsB,CAAC,KAAK,CAAC,iBAAiB,CAAC,EAAE;YAC1D,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,IAAA,4CAAoC,EACtD,KAAK,CAAC,iBAAiB,CACxB,CAAC;SACH;aAAM;YACL,MAAM,IAAI,KAAK;YACb,4EAA4E;YAC5E,kCAAkC,KAAK,CAAC,iBAAiB,EAAE,CAC5D,CAAC;SACH;IACH,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC;IACzC,CAAC;IACD,qBAAqB;QACnB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED,kBAAkB;QAChB,OAAO,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC;IAC3C,CAAC;IAED,uBAAuB;QACrB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC;IACzC,CAAC;IAED,qBAAqB;QACnB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED,uBAAuB;QACrB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED,sBAAsB;QACpB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAED,gBAAgB;QACd,IAAI,IAAI,CAAC,YAAY,CAAC,gBAAgB,KAAK,SAAS,EAAE;YACpD,OAAO,IAAI,CAAC;SACb;QACD,OAAO,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC;IAC5C,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,oBAAoB,EAAE,CAAC;IACpC,CAAC;CACF;AA3GD,gEA2GC;AASD;;;;;GAKG;AACH,MAAa,uBAAwB,SAAQ,0BAA0B;IAErE;;OAEG;IACH,YAAY,KAA4C;QACtD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,KAAK,GAAG,EAAC,uBAAuB,EAAE,KAAK,EAAC,CAAC;SAC1C;QACD,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAC7D,IAAI,CAAC,SAAS,EAAE;YACd,MAAM,IAAI,KAAK,CACb,yCAAyC,KAAK,CAAC,uBAAuB,EAAE,CACzE,CAAC;SACH;QACD,KAAK,CAAC;YACJ,SAAS,EAAE,SAAS;YACpB,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;SAC3C,CAAC,CAAC;QACH,IAAI,CAAC,uBAAuB,GAAG,KAAK,CAAC,uBAAuB,CAAC;IAC/D,CAAC;CACF;AArBD,0DAqBC;AAED,SAAgB,4BAA4B;IAC1C,6DAA6D;IAC7D,OAAO,kBAAkB,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;AAC1D,CAAC;AAHD,oEAGC;AAaD,MAAa,oBAAoB;IAI/B;;OAEG;IACH,YAAY,KAAiC;QAC3C,MAAM,QAAQ,GAAG,CAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,QAAQ,KAAI,WAAW,CAAC;QAChD,MAAM,IAAI,GAAG,CAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,IAAI,KAAI,IAAI,CAAC;QACjC,MAAM,oBAAoB,GAAG,GAAG,QAAQ,IAAI,IAAI,EAAE,CAAC;QAEnD,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,iBAAiB,KAAK,SAAS,EAAE;YAChE,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;YACjC,IAAI,CAAC,YAAY,GAAG;gBAClB,eAAe,EAAE,oBAAoB;gBACrC,aAAa,EAAE,oBAAoB;gBACnC,aAAa,EAAE,oBAAoB;gBACnC,gBAAgB,EAAE,KAAK;aACxB,CAAC;SACH;aAAM,IAAI,cAAc,CAAC,KAAK,CAAC,iBAAiB,CAAC,EAAE;YAClD,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,iBAAiB,CAAC;SAC7C;aAAM,IAAI,sBAAsB,CAAC,KAAK,CAAC,iBAAiB,CAAC,EAAE;YAC1D,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,IAAA,4CAAoC,EACtD,KAAK,CAAC,iBAAiB,CACxB,CAAC;SACH;aAAM;YACL,MAAM,IAAI,KAAK;YACb,4EAA4E;YAC5E,kCAAkC,KAAK,CAAC,iBAAiB,EAAE,CAC5D,CAAC;SACH;IACH,CAAC;IAED,YAAY;QACV,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC;IACzC,CAAC;IAED,qBAAqB;QACnB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED,kBAAkB;QAChB,OAAO,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC;IAC3C,CAAC;IAED,uBAAuB;QACrB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC;IACzC,CAAC;IAED,qBAAqB;QACnB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED,sBAAsB;QACpB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAED,gBAAgB;QACd,IAAI,IAAI,CAAC,YAAY,CAAC,gBAAgB,KAAK,SAAS,EAAE;YACpD,OAAO,IAAI,CAAC;SACb;QACD,OAAO,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC;IAC5C,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,oBAAoB,EAAE,CAAC;IACpC,CAAC;CACF;AA9ED,oDA8EC;AAED,MAAa,qBAAsB,SAAQ,sBAAsB;IAI/D;;OAEG;IACH,YAAY,KAAiC;QAC3C,KAAK,EAAE,CAAC;QACR,IAAI,GAAW,CAAC;QAChB,IAAI,WAAW,IAAI,KAAK,EAAE;YACxB,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC;SACvB;aAAM,IAAI,QAAQ,IAAI,KAAK,EAAE;YAC5B,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC;SACpB;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;SACnE;QACD,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE;YACf,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;SACtD;QACD,IAAI,CAAC,IAAA,kBAAU,EAAC,GAAG,CAAC,EAAE;YACpB,MAAM,IAAI,KAAK,CACb,iIAAiI,CAClI,CAAC;SACH;QAED,IAAI,QAAgB,CAAC;QACrB,IAAI,UAAU,IAAI,KAAK,EAAE;YACvB,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;SAC3B;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;SACxD;QACD,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;YACpB,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;SACvD;QAED,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;QAClB,IAAI,CAAC,YAAY,GAAG;YAClB,eAAe,EAAE,UAAU,GAAG,QAAQ;YACtC,aAAa,EAAE,QAAQ,GAAG,QAAQ;YAClC,aAAa,EAAE,QAAQ,GAAG,QAAQ;SACnC,CAAC;IACJ,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC;IACzC,CAAC;IACD,qBAAqB;QACnB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED,kBAAkB;QAChB,OAAO,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC;IAC3C,CAAC;IAED,uBAAuB;QACrB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC;IACzC,CAAC;IAED,qBAAqB;QACnB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED,uBAAuB;QACrB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED,sBAAsB;QACpB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,gBAAgB;QACd,IAAI,IAAI,CAAC,YAAY,CAAC,gBAAgB,KAAK,SAAS,EAAE;YACpD,OAAO,IAAI,CAAC;SACb;QACD,OAAO,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC;IAC5C,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,oBAAoB,EAAE,CAAC;IACpC,CAAC;CACF;AAzFD,sDAyFC;AAED,MAAa,yBAA0B,SAAQ,qBAAqB;IAClE;;OAEG;IACH,YAAY,KAAsC;QAChD,MAAM,YAAY,GAAG,CAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,YAAY,KAAI,iBAAiB,CAAC;QAC9D,MAAM,cAAc,GAAG,CAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,cAAc,KAAI,kBAAkB,CAAC;QAEnE,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAC7C,IAAI,CAAC,QAAQ,EAAE;YACb,MAAM,IAAI,KAAK,CAAC,wCAAwC,cAAc,EAAE,CAAC,CAAC;SAC3E;QACD,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;YACpB,MAAM,IAAI,KAAK,CACb,iCAAiC,cAAc,4BAA4B,CAC5E,CAAC;SACH;QAED,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAC5C,IAAI,CAAC,SAAS,EAAE;YACd,MAAM,IAAI,KAAK,CAAC,wCAAwC,YAAY,EAAE,CAAC,CAAC;SACzE;QACD,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;YACrB,MAAM,IAAI,KAAK,CACb,gCAAgC,YAAY,4BAA4B,CACzE,CAAC;SACH;QAED,IAAI,CAAC,IAAA,kBAAU,EAAC,SAAS,CAAC,EAAE;YAC1B,MAAM,IAAI,KAAK,CACb,8IAA8I,CAC/I,CAAC;SACH;QACD,KAAK,CAAC;YACJ,SAAS,EAAE,SAAS;YACpB,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;IACL,CAAC;CACF;AAtCD,8DAsCC","sourcesContent":["import {\n  AllEndpoints,\n  decodeAuthToken,\n  fromEntries,\n  isV2ApiKey,\n  populateAllEndpointsFromBaseEndpoint,\n} from '../internal/utils';\n\nexport interface BaseEndpointOverride {\n  baseEndpoint: string;\n  endpointPrefix?: string;\n  secureConnection?: boolean;\n}\n\nexport type EndpointOverrides = BaseEndpointOverride | AllEndpoints;\n\nfunction isBaseEndpointOverride(\n  endpointOverrides: EndpointOverrides\n): endpointOverrides is BaseEndpointOverride {\n  return (endpointOverrides as BaseEndpointOverride).baseEndpoint !== undefined;\n}\n\nfunction isAllEndpoints(\n  endpointOverrides: EndpointOverrides\n): endpointOverrides is AllEndpoints {\n  const allEndpoints = endpointOverrides as AllEndpoints;\n  return (\n    allEndpoints.cacheEndpoint !== undefined &&\n    allEndpoints.controlEndpoint !== undefined &&\n    allEndpoints.tokenEndpoint !== undefined\n  );\n}\n\n/**\n * Encapsulates arguments for instantiating an EnvMomentoTokenProvider\n */\ninterface CredentialProviderProps {\n  endpointOverrides?: EndpointOverrides;\n}\n\n/**\n * Provides information that the CacheClient needs in order to establish a connection to and authenticate with\n * the Momento service.\n * @export\n * @interface CredentialProvider\n */\nexport abstract class CredentialProvider {\n  /**\n   * @returns {string} Auth token provided by user, required to authenticate with the service\n   */\n  abstract getAuthToken(): string;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento control plane operations\n   */\n  abstract getControlEndpoint(): string;\n\n  /**\n   * @deprecated use isEndpointSecure() instead\n   */\n  abstract isControlEndpointSecure(): boolean;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento data plane operations\n   */\n  abstract getCacheEndpoint(): string;\n\n  /**\n   * @deprecated use isEndpointSecure() instead\n   */\n  abstract isCacheEndpointSecure(): boolean;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento token operations\n   */\n  abstract getTokenEndpoint(): string;\n\n  /**\n   * @deprecated use isEndpointSecure() instead\n   */\n  abstract isTokenEndpointSecure(): boolean;\n\n  /**\n   * @deprecated - use the static method forMomentoLocal instead\n   *\n   * Modifies the instance of the credential provider to override endpoints to\n   * allow insecure connections to the momento-local service for testing purposes\n   */\n  abstract withMomentoLocal(): CredentialProvider;\n\n  /**\n   * @returns {boolean} true if the endpoints were manually overridden at construction time; false otherwise\n   */\n  abstract areEndpointsOverridden(): boolean;\n  /**\n   * @returns {boolean} true if connecting to the endpoint connection with TLS; false if not using TLS\n   */\n  abstract isEndpointSecure(): boolean;\n\n  /**\n   * @deprecated use fromEnvVarV2() instead\n   */\n  static fromEnvironmentVariable(\n    props: EnvMomentoTokenProviderProps | string\n  ): CredentialProvider {\n    return new EnvMomentoTokenProvider(props);\n  }\n\n  /**\n   * @deprecated use fromEnvVarV2() instead\n   */\n  static fromEnvVar(\n    props: EnvMomentoTokenProviderProps | string\n  ): CredentialProvider {\n    return new EnvMomentoTokenProvider(props);\n  }\n\n  /**\n   * @deprecated use fromApiKeyV2() or fromDisposableToken() instead\n   */\n  static fromString(\n    props: StringMomentoTokenProviderProps | string\n  ): CredentialProvider {\n    return new StringMomentoTokenProvider(props);\n  }\n\n  static fromDisposableToken(\n    props: StringMomentoTokenProviderProps | string\n  ): CredentialProvider {\n    return new StringMomentoTokenProvider(props);\n  }\n\n  static fromEnvVarV2(\n    props?: EnvMomentoV2TokenProviderProps\n  ): CredentialProvider {\n    return new EnvMomentoV2TokenProvider(props);\n  }\n\n  static fromApiKeyV2(props: ApiKeyV2TokenProviderProps): CredentialProvider {\n    return new ApiKeyV2TokenProvider(props);\n  }\n\n  /**\n   * Allow insecure connections to momento-local service for testing purposes.\n   * Does not require a Momento API key.\n   * @param props configuration options for connecting to momento-local\n   * @returns CredentialProvider\n   */\n  static forMomentoLocal(props: MomentoLocalProviderProps): CredentialProvider {\n    return new MomentoLocalProvider(props);\n  }\n}\n\nabstract class CredentialProviderBase implements CredentialProvider {\n  abstract getAuthToken(): string;\n\n  abstract getCacheEndpoint(): string;\n\n  abstract isCacheEndpointSecure(): boolean;\n\n  abstract getControlEndpoint(): string;\n\n  abstract isControlEndpointSecure(): boolean;\n\n  abstract getTokenEndpoint(): string;\n\n  abstract isTokenEndpointSecure(): boolean;\n\n  abstract areEndpointsOverridden(): boolean;\n\n  abstract isEndpointSecure(): boolean;\n\n  abstract withMomentoLocal(): CredentialProvider;\n\n  valueOf(): object {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    const entries = Object.entries(this).filter(([k]) => k !== 'authToken');\n    const clone = fromEntries(entries);\n    return clone.valueOf();\n  }\n}\n\nexport interface StringMomentoApiKeyProviderProps\n  extends CredentialProviderProps {\n  /**\n   * apiKey the momento API key\n   */\n  apiKey: string;\n}\n\nexport interface StringMomentoAuthTokenProviderProps\n  extends CredentialProviderProps {\n  /**\n   * authToken the momento auth token\n   */\n  authToken: string;\n}\n\nexport type StringMomentoTokenProviderProps =\n  | StringMomentoApiKeyProviderProps\n  | StringMomentoAuthTokenProviderProps;\n\nexport type ApiKeyV2TokenProviderProps = StringMomentoTokenProviderProps & {\n  endpoint: string;\n};\n\nexport interface EnvMomentoV2TokenProviderProps {\n  apiKeyEnvVar?: string;\n  endpointEnvVar?: string;\n}\n\n/**\n * Reads and parses a momento auth token stored in a String\n * @export\n * @class StringMomentoTokenProvider\n * @deprecated use ApiKeyV2TokenProvider instead\n */\nexport class StringMomentoTokenProvider extends CredentialProviderBase {\n  private readonly apiKey: string;\n  private readonly allEndpoints: AllEndpoints;\n  private readonly endpointsOverridden: boolean;\n\n  /**\n   * @param {StringMomentoTokenProviderProps} props configuration options for the token provider\n   */\n  constructor(props: StringMomentoTokenProviderProps | string) {\n    if (typeof props === 'string') {\n      props = {apiKey: props};\n    }\n    super();\n    let key: string;\n    if ('authToken' in props) {\n      key = props.authToken;\n    } else if ('apiKey' in props) {\n      key = props.apiKey;\n    } else {\n      throw new Error('Missing required property: authToken or apiKey');\n    }\n    const decodedToken = decodeAuthToken(key);\n    this.apiKey = decodedToken.authToken;\n    if (props.endpointOverrides === undefined) {\n      this.endpointsOverridden = false;\n      if (decodedToken.controlEndpoint === undefined) {\n        throw new Error(\n          'Malformed token; unable to determine control endpoint.  Depending on the type of token you are using, you may need to specify the controlEndpoint explicitly.'\n        );\n      }\n      if (decodedToken.cacheEndpoint === undefined) {\n        throw new Error(\n          'Malformed token; unable to determine cache endpoint.  Depending on the type of token you are using, you may need to specify the cacheEndpoint explicitly.'\n        );\n      }\n      if (decodedToken.tokenEndpoint === undefined) {\n        throw new Error(\n          'Malformed token; unable to determine token endpoint.  Depending on the type of token you are using, you may need to specify the tokenEndpoint explicitly.'\n        );\n      }\n\n      this.allEndpoints = {\n        controlEndpoint: decodedToken.controlEndpoint,\n        cacheEndpoint: decodedToken.cacheEndpoint,\n        tokenEndpoint: decodedToken.tokenEndpoint,\n      };\n    } else if (isAllEndpoints(props.endpointOverrides)) {\n      this.endpointsOverridden = true;\n      this.allEndpoints = props.endpointOverrides;\n    } else if (isBaseEndpointOverride(props.endpointOverrides)) {\n      this.endpointsOverridden = true;\n      this.allEndpoints = populateAllEndpointsFromBaseEndpoint(\n        props.endpointOverrides\n      );\n    } else {\n      throw new Error(\n        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n        `Unsupported endpointOverrides: ${props.endpointOverrides}`\n      );\n    }\n  }\n\n  getAuthToken(): string {\n    return this.apiKey;\n  }\n\n  getCacheEndpoint(): string {\n    return this.allEndpoints.cacheEndpoint;\n  }\n  isCacheEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  getControlEndpoint(): string {\n    return this.allEndpoints.controlEndpoint;\n  }\n\n  isControlEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  getTokenEndpoint(): string {\n    return this.allEndpoints.tokenEndpoint;\n  }\n\n  isTokenEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  isStorageEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  areEndpointsOverridden(): boolean {\n    return this.endpointsOverridden;\n  }\n\n  isEndpointSecure(): boolean {\n    if (this.allEndpoints.secureConnection === undefined) {\n      return true;\n    }\n    return this.allEndpoints.secureConnection;\n  }\n\n  withMomentoLocal(): CredentialProvider {\n    return new MomentoLocalProvider();\n  }\n}\n\nexport interface EnvMomentoTokenProviderProps extends CredentialProviderProps {\n  /**\n   * the name of the environment variable from which the auth token will be read\n   */\n  environmentVariableName: string;\n}\n\n/**\n * Reads and parses a momento auth token stored as an environment variable.\n * @export\n * @class EnvMomentoTokenProvider\n * @deprecated use EnvMomentoV2TokenProvider instead\n */\nexport class EnvMomentoTokenProvider extends StringMomentoTokenProvider {\n  environmentVariableName: string;\n  /**\n   * @param {EnvMomentoTokenProviderProps} props configuration options for the token provider\n   */\n  constructor(props: EnvMomentoTokenProviderProps | string) {\n    if (typeof props === 'string') {\n      props = {environmentVariableName: props};\n    }\n    const authToken = process.env[props.environmentVariableName];\n    if (!authToken) {\n      throw new Error(\n        `Missing required environment variable ${props.environmentVariableName}`\n      );\n    }\n    super({\n      authToken: authToken,\n      endpointOverrides: props.endpointOverrides,\n    });\n    this.environmentVariableName = props.environmentVariableName;\n  }\n}\n\nexport function getDefaultCredentialProvider(): CredentialProvider {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n  return CredentialProvider.fromEnvVar('MOMENTO_API_KEY');\n}\n\nexport interface MomentoLocalProviderProps extends CredentialProviderProps {\n  /**\n   * The hostname of the momento-local service\n   */\n  hostname?: string;\n  /**\n   * The port of the momento-local service\n   */\n  port?: number;\n}\n\nexport class MomentoLocalProvider implements CredentialProvider {\n  private readonly allEndpoints: AllEndpoints;\n  private readonly endpointsOverridden: boolean;\n\n  /**\n   * @param {MomentoLocalProviderProps} props configuration options for connecting to momento-local\n   */\n  constructor(props?: MomentoLocalProviderProps) {\n    const hostname = props?.hostname || '127.0.0.1';\n    const port = props?.port || 8080;\n    const momentoLocalEndpoint = `${hostname}:${port}`;\n\n    if (props === undefined || props.endpointOverrides === undefined) {\n      this.endpointsOverridden = false;\n      this.allEndpoints = {\n        controlEndpoint: momentoLocalEndpoint,\n        cacheEndpoint: momentoLocalEndpoint,\n        tokenEndpoint: momentoLocalEndpoint,\n        secureConnection: false,\n      };\n    } else if (isAllEndpoints(props.endpointOverrides)) {\n      this.endpointsOverridden = true;\n      this.allEndpoints = props.endpointOverrides;\n    } else if (isBaseEndpointOverride(props.endpointOverrides)) {\n      this.endpointsOverridden = true;\n      this.allEndpoints = populateAllEndpointsFromBaseEndpoint(\n        props.endpointOverrides\n      );\n    } else {\n      throw new Error(\n        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n        `Unsupported endpointOverrides: ${props.endpointOverrides}`\n      );\n    }\n  }\n\n  getAuthToken(): string {\n    return '';\n  }\n\n  getCacheEndpoint(): string {\n    return this.allEndpoints.cacheEndpoint;\n  }\n\n  isCacheEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  getControlEndpoint(): string {\n    return this.allEndpoints.controlEndpoint;\n  }\n\n  isControlEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  getTokenEndpoint(): string {\n    return this.allEndpoints.tokenEndpoint;\n  }\n\n  isTokenEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  areEndpointsOverridden(): boolean {\n    return this.endpointsOverridden;\n  }\n\n  isEndpointSecure(): boolean {\n    if (this.allEndpoints.secureConnection === undefined) {\n      return true;\n    }\n    return this.allEndpoints.secureConnection;\n  }\n\n  withMomentoLocal(): CredentialProvider {\n    return new MomentoLocalProvider();\n  }\n}\n\nexport class ApiKeyV2TokenProvider extends CredentialProviderBase {\n  private readonly apiKey: string;\n  private readonly allEndpoints: AllEndpoints;\n\n  /**\n   * @param {ApiKeyV2TokenProviderProps} props configuration options for the token provider\n   */\n  constructor(props: ApiKeyV2TokenProviderProps) {\n    super();\n    let key: string;\n    if ('authToken' in props) {\n      key = props.authToken;\n    } else if ('apiKey' in props) {\n      key = props.apiKey;\n    } else {\n      throw new Error('Missing required property: authToken or apiKey');\n    }\n    if (!key.length) {\n      throw new Error('API key cannot be an empty string');\n    }\n    if (!isV2ApiKey(key)) {\n      throw new Error(\n        'Received an invalid v2 API key. Are you using the correct key? Or did you mean to use `fromString()` with a legacy key instead?'\n      );\n    }\n\n    let endpoint: string;\n    if ('endpoint' in props) {\n      endpoint = props.endpoint;\n    } else {\n      throw new Error('Missing required property: endpoint');\n    }\n    if (!endpoint.length) {\n      throw new Error('Endpoint cannot be an empty string');\n    }\n\n    this.apiKey = key;\n    this.allEndpoints = {\n      controlEndpoint: 'control.' + endpoint,\n      cacheEndpoint: 'cache.' + endpoint,\n      tokenEndpoint: 'token.' + endpoint,\n    };\n  }\n\n  getAuthToken(): string {\n    return this.apiKey;\n  }\n\n  getCacheEndpoint(): string {\n    return this.allEndpoints.cacheEndpoint;\n  }\n  isCacheEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  getControlEndpoint(): string {\n    return this.allEndpoints.controlEndpoint;\n  }\n\n  isControlEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  getTokenEndpoint(): string {\n    return this.allEndpoints.tokenEndpoint;\n  }\n\n  isTokenEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  isStorageEndpointSecure(): boolean {\n    return this.isEndpointSecure();\n  }\n\n  areEndpointsOverridden(): boolean {\n    return false;\n  }\n\n  isEndpointSecure(): boolean {\n    if (this.allEndpoints.secureConnection === undefined) {\n      return true;\n    }\n    return this.allEndpoints.secureConnection;\n  }\n\n  withMomentoLocal(): CredentialProvider {\n    return new MomentoLocalProvider();\n  }\n}\n\nexport class EnvMomentoV2TokenProvider extends ApiKeyV2TokenProvider {\n  /**\n   * @param {EnvMomentoV2TokenProviderProps} props configuration options for the token provider\n   */\n  constructor(props?: EnvMomentoV2TokenProviderProps) {\n    const apiKeyEnvVar = props?.apiKeyEnvVar || 'MOMENTO_API_KEY';\n    const endpointEnvVar = props?.endpointEnvVar || 'MOMENTO_ENDPOINT';\n\n    const endpoint = process.env[endpointEnvVar];\n    if (!endpoint) {\n      throw new Error(`Empty value for environment variable ${endpointEnvVar}`);\n    }\n    if (!endpoint.length) {\n      throw new Error(\n        `Endpoint environment variable ${endpointEnvVar} cannot be an empty string`\n      );\n    }\n\n    const authToken = process.env[apiKeyEnvVar];\n    if (!authToken) {\n      throw new Error(`Empty value for environment variable ${apiKeyEnvVar}`);\n    }\n    if (!authToken.length) {\n      throw new Error(\n        `API key environment variable ${apiKeyEnvVar} cannot be an empty string`\n      );\n    }\n\n    if (!isV2ApiKey(authToken)) {\n      throw new Error(\n        'Received an invalid v2 API key. Are you using the correct key? Or did you mean to use `fromEnvironmentVariable()` with a legacy key instead?'\n      );\n    }\n    super({\n      authToken: authToken,\n      endpoint: endpoint,\n    });\n  }\n}\n"]}

package/dist/src/clients/ICacheClient.d.ts

@@ -1,5 +1,5 @@
 import { CacheDelete, CacheGet, CacheGetWithHash, CacheIncrement, CacheSet, CacheSetIfNotExists, CacheSetFetch, CacheSetAddElements, CacheSetAddElement, CacheSetContainsElement, CacheSetContainsElements, CacheSetRemoveElements, CacheSetRemoveElement, CacheListFetch, CacheListLength, CacheListPushFront, CacheListPushBack, CacheListConcatenateBack, CacheListConcatenateFront, CacheListPopBack, CacheListPopFront, CacheListRemoveValue, CacheListRetain, CacheDictionarySetField, CacheDictionarySetFields, CacheDictionaryGetField, CacheDictionaryFetch, CacheDictionaryIncrement, CacheDictionaryRemoveField, CacheDictionaryRemoveFields, CacheDictionaryLength, CacheSortedSetFetch, CacheSortedSetPutElement, CacheSortedSetPutElements, CacheSortedSetGetRank, CacheSortedSetGetScore, CacheSortedSetGetScores, CacheSortedSetIncrementScore, CacheSortedSetRemoveElement, CacheSortedSetLength, CacheSortedSetLengthByScore, CacheItemGetType, CacheItemGetTtl, CacheKeyExists, CacheKeysExist, CacheUpdateTtl, CacheIncreaseTtl, CacheDecreaseTtl, CacheDictionaryGetFields, CacheGetBatch, CacheSetBatch, CacheSetIfAbsent, CacheSetIfPresent, CacheSetIfEqual, CacheSetIfNotEqual, CacheSetIfPresentAndNotEqual, CacheSetIfAbsentOrEqual, CacheSetSample, CacheSortedSetRemoveElements, CacheSetPop, CacheSetLength, CacheSortedSetUnionStore, CacheSetWithHash, CacheSetIfPresentAndHashEqual, CacheSetIfPresentAndHashNotEqual, CacheSetIfAbsentOrHashEqual, CacheSetIfAbsentOrHashNotEqual } from '../index';
-import { ScalarCallOptions, ListFetchCallOptions, ListRetainCallOptions, BackTruncatableCallOptions, FrontTruncatableCallOptions, CollectionCallOptions, SortedSetFetchByRankCallOptions, SortedSetFetchByScoreCallOptions, SortedSetLengthByScoreCallOptions, SortedSetGetRankCallOptions, SetCallOptions, GetCallOptions, SetIfAbsentCallOptions, SetBatchItem, SortedSetSource, SortedSetUnionStoreCallOptions, GetWithHashCallOptions, SetWithHashCallOptions } from '../utils';
+import { ListFetchCallOptions, ListRetainCallOptions, BackTruncatableCallOptions, FrontTruncatableCallOptions, CollectionCallOptions, SortedSetFetchByRankCallOptions, SortedSetFetchByScoreCallOptions, SortedSetLengthByScoreCallOptions, SortedSetGetRankCallOptions, SetCallOptions, GetCallOptions, SetIfAbsentCallOptions, SetBatchItem, SortedSetSource, SortedSetUnionStoreCallOptions, GetWithHashCallOptions, SetWithHashCallOptions, CancellationCallOptions, ScalarCallOptions } from '../utils';
 import { IControlClient, IPingClient } from '../internal/clients';
 import { IMomentoCache } from './IMomentoCache';
 export type SetOptions = SetCallOptions;
@@ -37,11 +37,35 @@ export type SetIfPresentAndHashEqualOptions = ScalarCallOptions;
 export type SetIfPresentAndHashNotEqualOptions = ScalarCallOptions;
 export type SetIfAbsentOrHashEqualOptions = ScalarCallOptions;
 export type SetIfAbsentOrHashNotEqualOptions = ScalarCallOptions;
+export type SetFetchOptions = CancellationCallOptions;
+export type DeleteOptions = CancellationCallOptions;
+export type SetContainsElementsOptions = CancellationCallOptions;
+export type SetRemoveElementsOptions = CancellationCallOptions;
+export type SetSampleOptions = CancellationCallOptions;
+export type SetPopOptions = CancellationCallOptions;
+export type SetLengthOptions = CancellationCallOptions;
+export type ListLengthOptions = CancellationCallOptions;
+export type ListPopBackOptions = CancellationCallOptions;
+export type ListPopFrontOptions = CancellationCallOptions;
+export type ListRemoveValueOptions = CancellationCallOptions;
+export type DictionaryGetFieldOptions = CancellationCallOptions;
+export type DictionaryFetchOptions = CancellationCallOptions;
+export type DictionaryRemoveFieldOptions = CancellationCallOptions;
+export type DictionaryLengthOptions = CancellationCallOptions;
+export type SortedSetGetScoreOptions = CancellationCallOptions;
+export type SortedSetRemoveElementOptions = CancellationCallOptions;
+export type SortedSetLengthOptions = CancellationCallOptions;
+export type ItemGetTypeOptions = CancellationCallOptions;
+export type ItemGetTtlOptions = CancellationCallOptions;
+export type KeyExistsOptions = CancellationCallOptions;
+export type UpdateTtlOptions = CancellationCallOptions;
+export type IncreaseTtlOptions = CancellationCallOptions;
+export type DecreaseTtlOptions = CancellationCallOptions;
 export interface ICacheClient extends IControlClient, IPingClient {
     cache(cacheName: string): IMomentoCache;
     get(cacheName: string, key: string | Uint8Array, options?: GetOptions): Promise<CacheGet.Response>;
     set(cacheName: string, key: string | Uint8Array, value: string | Uint8Array, options?: SetOptions): Promise<CacheSet.Response>;
-    delete(cacheName: string, key: string | Uint8Array): Promise<CacheDelete.Response>;
+    delete(cacheName: string, key: string | Uint8Array, options?: DeleteOptions): Promise<CacheDelete.Response>;
     increment(cacheName: string, field: string | Uint8Array, amount: number, options?: IncrementOptions): Promise<CacheIncrement.Response>;
     /**
      * @deprecated use setIfAbsent instead.
@@ -57,58 +81,58 @@ export interface ICacheClient extends IControlClient, IPingClient {
     setIfPresentAndHashNotEqual(cacheName: string, key: string | Uint8Array, value: string | Uint8Array, hashNotEqual: Uint8Array, options?: SetIfPresentAndHashNotEqualOptions): Promise<CacheSetIfPresentAndHashNotEqual.Response>;
     setIfAbsentOrHashEqual(cacheName: string, key: string | Uint8Array, value: string | Uint8Array, hashEqual: Uint8Array, options?: SetIfAbsentOrHashEqualOptions): Promise<CacheSetIfAbsentOrHashEqual.Response>;
     setIfAbsentOrHashNotEqual(cacheName: string, key: string | Uint8Array, value: string | Uint8Array, hashNotEqual: Uint8Array, options?: SetIfAbsentOrHashNotEqualOptions): Promise<CacheSetIfAbsentOrHashNotEqual.Response>;
-    getBatch(cacheName: string, keys: Array<string | Uint8Array>): Promise<CacheGetBatch.Response>;
+    getBatch(cacheName: string, keys: Array<string | Uint8Array>, options?: GetBatchOptions): Promise<CacheGetBatch.Response>;
     setBatch(cacheName: string, items: Record<string, string | Uint8Array> | Map<string | Uint8Array, string | Uint8Array> | Array<SetBatchItem>, options?: SetBatchOptions): Promise<CacheSetBatch.Response>;
     getWithHash(cacheName: string, key: string | Uint8Array, options?: GetWithHashOptions): Promise<CacheGetWithHash.Response>;
     setWithHash(cacheName: string, key: string | Uint8Array, value: string | Uint8Array, options?: SetWithHashOptions): Promise<CacheSetWithHash.Response>;
-    setFetch(cacheName: string, setName: string): Promise<CacheSetFetch.Response>;
+    setFetch(cacheName: string, setName: string, options?: SetFetchOptions): Promise<CacheSetFetch.Response>;
     setAddElement(cacheName: string, setName: string, element: string | Uint8Array, options?: SetAddElementsOptions): Promise<CacheSetAddElement.Response>;
     setAddElements(cacheName: string, setName: string, elements: string[] | Uint8Array[], options?: SetAddElementsOptions): Promise<CacheSetAddElements.Response>;
-    setContainsElement(cacheName: string, setName: string, element: string | Uint8Array): Promise<CacheSetContainsElement.Response>;
-    setContainsElements(cacheName: string, setName: string, elements: string[] | Uint8Array[]): Promise<CacheSetContainsElements.Response>;
-    setRemoveElement(cacheName: string, setName: string, element: string | Uint8Array): Promise<CacheSetRemoveElement.Response>;
-    setRemoveElements(cacheName: string, setName: string, elements: string[] | Uint8Array[]): Promise<CacheSetRemoveElements.Response>;
-    setSample(cacheName: string, setName: string, limit: number): Promise<CacheSetSample.Response>;
-    setPop(cacheName: string, setName: string, count: number): Promise<CacheSetPop.Response>;
-    setLength(cacheName: string, setName: string): Promise<CacheSetLength.Response>;
+    setContainsElement(cacheName: string, setName: string, element: string | Uint8Array, options?: SetContainsElementsOptions): Promise<CacheSetContainsElement.Response>;
+    setContainsElements(cacheName: string, setName: string, elements: string[] | Uint8Array[], options?: SetContainsElementsOptions): Promise<CacheSetContainsElements.Response>;
+    setRemoveElement(cacheName: string, setName: string, element: string | Uint8Array, options?: SetRemoveElementsOptions): Promise<CacheSetRemoveElement.Response>;
+    setRemoveElements(cacheName: string, setName: string, elements: string[] | Uint8Array[], options?: SetRemoveElementsOptions): Promise<CacheSetRemoveElements.Response>;
+    setSample(cacheName: string, setName: string, limit: number, options?: SetSampleOptions): Promise<CacheSetSample.Response>;
+    setPop(cacheName: string, setName: string, count: number, options?: SetPopOptions): Promise<CacheSetPop.Response>;
+    setLength(cacheName: string, setName: string, options?: SetLengthOptions): Promise<CacheSetLength.Response>;
     listFetch(cacheName: string, listName: string, options?: ListFetchCallOptions): Promise<CacheListFetch.Response>;
-    listLength(cacheName: string, listName: string): Promise<CacheListLength.Response>;
+    listLength(cacheName: string, listName: string, options?: ListLengthOptions): Promise<CacheListLength.Response>;
     listPushFront(cacheName: string, listName: string, value: string | Uint8Array, options?: ListPushFrontOptions): Promise<CacheListPushFront.Response>;
     listPushBack(cacheName: string, listName: string, value: string | Uint8Array, options?: ListPushBackOptions): Promise<CacheListPushBack.Response>;
     listConcatenateBack(cacheName: string, listName: string, values: string[] | Uint8Array[], options?: ListConcatenateBackOptions): Promise<CacheListConcatenateBack.Response>;
     listConcatenateFront(cacheName: string, listName: string, values: string[] | Uint8Array[], options?: ListConcatenateFrontOptions): Promise<CacheListConcatenateFront.Response>;
-    listPopBack(cacheName: string, listName: string): Promise<CacheListPopBack.Response>;
-    listPopFront(cacheName: string, listName: string): Promise<CacheListPopFront.Response>;
-    listRemoveValue(cacheName: string, listName: string, value: string | Uint8Array): Promise<CacheListRemoveValue.Response>;
+    listPopBack(cacheName: string, listName: string, options?: ListPopBackOptions): Promise<CacheListPopBack.Response>;
+    listPopFront(cacheName: string, listName: string, options?: ListPopFrontOptions): Promise<CacheListPopFront.Response>;
+    listRemoveValue(cacheName: string, listName: string, value: string | Uint8Array, options?: ListRemoveValueOptions): Promise<CacheListRemoveValue.Response>;
     listRetain(cacheName: string, listName: string, options?: ListRetainCallOptions): Promise<CacheListRetain.Response>;
     dictionarySetField(cacheName: string, dictionaryName: string, field: string | Uint8Array, value: string | Uint8Array, options?: DictionarySetFieldOptions): Promise<CacheDictionarySetField.Response>;
     dictionarySetFields(cacheName: string, dictionaryName: string, elements: Map<string | Uint8Array, string | Uint8Array> | Record<string, string | Uint8Array> | Array<[string, string | Uint8Array]>, options?: DictionarySetFieldsOptions): Promise<CacheDictionarySetFields.Response>;
-    dictionaryGetField(cacheName: string, dictionaryName: string, field: string | Uint8Array): Promise<CacheDictionaryGetField.Response>;
-    dictionaryGetFields(cacheName: string, dictionaryName: string, fields: string[] | Uint8Array[]): Promise<CacheDictionaryGetFields.Response>;
-    dictionaryFetch(cacheName: string, dictionaryName: string): Promise<CacheDictionaryFetch.Response>;
+    dictionaryGetField(cacheName: string, dictionaryName: string, field: string | Uint8Array, options?: DictionaryGetFieldOptions): Promise<CacheDictionaryGetField.Response>;
+    dictionaryGetFields(cacheName: string, dictionaryName: string, fields: string[] | Uint8Array[], options?: DictionaryGetFieldOptions): Promise<CacheDictionaryGetFields.Response>;
+    dictionaryFetch(cacheName: string, dictionaryName: string, options?: DictionaryFetchOptions): Promise<CacheDictionaryFetch.Response>;
     dictionaryIncrement(cacheName: string, dictionaryName: string, field: string | Uint8Array, amount?: number, options?: DictionaryIncrementOptions): Promise<CacheDictionaryIncrement.Response>;
-    dictionaryRemoveField(cacheName: string, dictionaryName: string, field: string | Uint8Array): Promise<CacheDictionaryRemoveField.Response>;
-    dictionaryRemoveFields(cacheName: string, dictionaryName: string, fields: string[] | Uint8Array[]): Promise<CacheDictionaryRemoveFields.Response>;
-    dictionaryLength(cacheName: string, dictionaryName: string): Promise<CacheDictionaryLength.Response>;
+    dictionaryRemoveField(cacheName: string, dictionaryName: string, field: string | Uint8Array, options?: DictionaryRemoveFieldOptions): Promise<CacheDictionaryRemoveField.Response>;
+    dictionaryRemoveFields(cacheName: string, dictionaryName: string, fields: string[] | Uint8Array[], options?: DictionaryRemoveFieldOptions): Promise<CacheDictionaryRemoveFields.Response>;
+    dictionaryLength(cacheName: string, dictionaryName: string, options?: DictionaryLengthOptions): Promise<CacheDictionaryLength.Response>;
     sortedSetFetchByRank(cacheName: string, sortedSetName: string, options?: SortedSetFetchByRankOptions): Promise<CacheSortedSetFetch.Response>;
     sortedSetFetchByScore(cacheName: string, sortedSetName: string, options?: SortedSetFetchByScoreOptions): Promise<CacheSortedSetFetch.Response>;
     sortedSetPutElement(cacheName: string, sortedSetName: string, value: string | Uint8Array, score: number, options?: SortedSetPutElementOptions): Promise<CacheSortedSetPutElement.Response>;
     sortedSetPutElements(cacheName: string, sortedSetName: string, elements: Map<string | Uint8Array, number> | Record<string, number> | Array<[string, number]>, options?: SortedSetPutElementsOptions): Promise<CacheSortedSetPutElements.Response>;
     sortedSetGetRank(cacheName: string, sortedSetName: string, value: string | Uint8Array, options?: SortedSetGetRankOptions): Promise<CacheSortedSetGetRank.Response>;
-    sortedSetGetScore(cacheName: string, sortedSetName: string, value: string | Uint8Array): Promise<CacheSortedSetGetScore.Response>;
-    sortedSetGetScores(cacheName: string, sortedSetName: string, values: string[] | Uint8Array[]): Promise<CacheSortedSetGetScores.Response>;
+    sortedSetGetScore(cacheName: string, sortedSetName: string, value: string | Uint8Array, options?: SortedSetGetScoreOptions): Promise<CacheSortedSetGetScore.Response>;
+    sortedSetGetScores(cacheName: string, sortedSetName: string, values: string[] | Uint8Array[], options?: SortedSetGetScoreOptions): Promise<CacheSortedSetGetScores.Response>;
     sortedSetIncrementScore(cacheName: string, sortedSetName: string, value: string | Uint8Array, amount?: number, options?: SortedSetIncrementOptions): Promise<CacheSortedSetIncrementScore.Response>;
-    sortedSetRemoveElement(cacheName: string, sortedSetName: string, value: string | Uint8Array): Promise<CacheSortedSetRemoveElement.Response>;
-    sortedSetRemoveElements(cacheName: string, sortedSetName: string, values: string[] | Uint8Array[]): Promise<CacheSortedSetRemoveElements.Response>;
-    sortedSetLength(cacheName: string, sortedSetName: string): Promise<CacheSortedSetLength.Response>;
+    sortedSetRemoveElement(cacheName: string, sortedSetName: string, value: string | Uint8Array, options?: SortedSetRemoveElementOptions): Promise<CacheSortedSetRemoveElement.Response>;
+    sortedSetRemoveElements(cacheName: string, sortedSetName: string, values: string[] | Uint8Array[], options?: SortedSetRemoveElementOptions): Promise<CacheSortedSetRemoveElements.Response>;
+    sortedSetLength(cacheName: string, sortedSetName: string, options?: SortedSetLengthOptions): Promise<CacheSortedSetLength.Response>;
     sortedSetLengthByScore(cacheName: string, sortedSetName: string, options?: SortedSetLengthByScoreOptions): Promise<CacheSortedSetLengthByScore.Response>;
     sortedSetUnionStore(cacheName: string, sortedSetName: string, sources: SortedSetSource[], options?: SortedSetUnionStoreOptions): Promise<CacheSortedSetUnionStore.Response>;
-    itemGetType(cacheName: string, key: string | Uint8Array): Promise<CacheItemGetType.Response>;
-    itemGetTtl(cacheName: string, key: string | Uint8Array): Promise<CacheItemGetTtl.Response>;
-    keyExists(cacheName: string, key: string | Uint8Array): Promise<CacheKeyExists.Response>;
-    keysExist(cacheName: string, keys: string[] | Uint8Array[]): Promise<CacheKeysExist.Response>;
-    updateTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number): Promise<CacheUpdateTtl.Response>;
-    increaseTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number): Promise<CacheIncreaseTtl.Response>;
-    decreaseTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number): Promise<CacheDecreaseTtl.Response>;
+    itemGetType(cacheName: string, key: string | Uint8Array, options?: ItemGetTypeOptions): Promise<CacheItemGetType.Response>;
+    itemGetTtl(cacheName: string, key: string | Uint8Array, options?: ItemGetTtlOptions): Promise<CacheItemGetTtl.Response>;
+    keyExists(cacheName: string, key: string | Uint8Array, options?: KeyExistsOptions): Promise<CacheKeyExists.Response>;
+    keysExist(cacheName: string, keys: string[] | Uint8Array[], options?: KeyExistsOptions): Promise<CacheKeysExist.Response>;
+    updateTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number, options?: UpdateTtlOptions): Promise<CacheUpdateTtl.Response>;
+    increaseTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number, options?: IncreaseTtlOptions): Promise<CacheIncreaseTtl.Response>;
+    decreaseTtl(cacheName: string, key: string | Uint8Array, ttlMilliseconds: number, options?: DecreaseTtlOptions): Promise<CacheDecreaseTtl.Response>;
     close(): void;
 }