@wildix/wim-cache-client 1.0.0 → 1.0.2

package/dist-es/protocols/Aws_restJson1.js

@@ -1,137 +1,124 @@
 import { WimCacheServiceException as __BaseException } from "../models/WimCacheServiceException";
-import { ValidationException, } from "../models/models_0";
-import { HttpRequest as __HttpRequest, } from "@smithy/protocol-http";
+import { ForbiddenException, ValidationException, } from "../models/models_0";
+import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
+import { requestBuilder as rb } from "@smithy/core";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, _json, collectBody, map, take, withBaseException, } from "@smithy/smithy-client";
 export const se_DeleteEntitiesFromGeneralCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v1/cache/general";
+    b.bp("/v1/cache/general");
     const query = map({
-        "email": [, input.email],
-        "phone": [, input.phone],
-        "clean": [() => input.clean !== void 0, () => (input.clean.toString())],
+        [_e]: [, input[_e]],
+        [_p]: [, input[_p]],
+        [_c]: [() => input.clean !== void 0, () => (input[_c].toString())],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("DELETE")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_GetEntitiesByIdsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         'content-type': 'application/json',
     };
-    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v1/cache/object";
+    b.bp("/v1/cache/object");
     let body;
     body = JSON.stringify(take(input, {
         'entityIds': _ => _json(_),
         'organizationId': [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
 };
 export const se_PutEntitiesToGeneralCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         'content-type': 'application/json',
     };
-    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v1/cache/general";
+    b.bp("/v1/cache/general");
     let body;
     body = JSON.stringify(take(input, {
         'items': _ => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT")
+        .h(headers)
+        .b(body);
+    return b.build();
 };
 export const se_SearchEntitiesByListParamsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         'content-type': 'application/json',
     };
-    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v1/cache/search";
+    b.bp("/v1/cache/search");
     let body;
     body = JSON.stringify(take(input, {
         'organizationId': [],
         'params': _ => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
 };
 export const se_SearchEntitiesByParamsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v1/cache/search";
+    b.bp("/v1/cache/search");
     const query = map({
-        "organizationId": [, input.organizationId],
-        "phone": [, input.phone],
-        "email": [, input.email],
-        "query": [, input.query],
-        "from": [() => input.from !== void 0, () => (input.from.toString())],
-        "size": [() => input.size !== void 0, () => (input.size.toString())],
+        [_oI]: [, input[_oI]],
+        [_p]: [, input[_p]],
+        [_e]: [, input[_e]],
+        [_q]: [, input[_q]],
+        [_f]: [() => input.from !== void 0, () => (input[_f].toString())],
+        [_s]: [() => input.size !== void 0, () => (input[_s].toString())],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_SyncCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         'content-type': 'application/json',
     };
-    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v1/cache/sync";
+    b.bp("/v1/cache/sync");
     let body;
     body = JSON.stringify(take(input, {
         'organizationId': [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_UpdateEntitiesWeightCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/v1/cache/weight");
+    let body;
+    body = JSON.stringify(take(input, {
+        'entityIds': _ => _json(_),
+        'organizationId': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
 };
 export const de_DeleteEntitiesFromGeneralCacheCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_DeleteEntitiesFromGeneralCacheCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -139,28 +126,9 @@ export const de_DeleteEntitiesFromGeneralCacheCommand = async (output, context)
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteEntitiesFromGeneralCacheCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_GetEntitiesByIdsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetEntitiesByIdsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -172,28 +140,9 @@ export const de_GetEntitiesByIdsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetEntitiesByIdsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_PutEntitiesToGeneralCacheCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_PutEntitiesToGeneralCacheCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -201,28 +150,9 @@ export const de_PutEntitiesToGeneralCacheCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_PutEntitiesToGeneralCacheCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_SearchEntitiesByListParamsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_SearchEntitiesByListParamsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -234,28 +164,9 @@ export const de_SearchEntitiesByListParamsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_SearchEntitiesByListParamsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_SearchEntitiesByParamsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_SearchEntitiesByParamsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -267,28 +178,23 @@ export const de_SearchEntitiesByParamsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_SearchEntitiesByParamsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
+export const de_SyncCacheCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'success': __expectBoolean,
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
-export const de_SyncCacheCommand = async (output, context) => {
+export const de_UpdateEntitiesWeightCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_SyncCacheCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -300,13 +206,16 @@ export const de_SyncCacheCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_SyncCacheCommandError = async (output, context) => {
+const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context)
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "ForbiddenException":
+        case "smithy.framework#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "smithy.framework#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
@@ -320,6 +229,19 @@ const de_SyncCacheCommandError = async (output, context) => {
     }
 };
 const throwDefaultError = withBaseException(__BaseException);
+const de_ForbiddenExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ForbiddenException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ValidationExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -340,49 +262,10 @@ const deserializeMetadata = (output) => ({
     cfId: output.headers["x-amz-cf-id"],
 });
 const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then(body => context.utf8Encoder(body));
-const isSerializableHeaderValue = (value) => value !== undefined &&
-    value !== null &&
-    value !== "" &&
-    (!Object.getOwnPropertyNames(value).includes("length") ||
-        value.length != 0) &&
-    (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
-const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then(encoded => {
-    if (encoded.length) {
-        return JSON.parse(encoded);
-    }
-    return {};
-});
-const parseErrorBody = async (errorBody, context) => {
-    const value = await parseBody(errorBody, context);
-    value.message = value.message ?? value.Message;
-    return value;
-};
-const loadRestJsonErrorCode = (output, data) => {
-    const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
-    const sanitizeErrorCode = (rawValue) => {
-        let cleanValue = rawValue;
-        if (typeof cleanValue === "number") {
-            cleanValue = cleanValue.toString();
-        }
-        if (cleanValue.indexOf(",") >= 0) {
-            cleanValue = cleanValue.split(",")[0];
-        }
-        if (cleanValue.indexOf(":") >= 0) {
-            cleanValue = cleanValue.split(":")[0];
-        }
-        if (cleanValue.indexOf("#") >= 0) {
-            cleanValue = cleanValue.split("#")[1];
-        }
-        return cleanValue;
-    };
-    const headerKey = findKey(output.headers, "x-amzn-errortype");
-    if (headerKey !== undefined) {
-        return sanitizeErrorCode(output.headers[headerKey]);
-    }
-    if (data.code !== undefined) {
-        return sanitizeErrorCode(data.code);
-    }
-    if (data["__type"] !== undefined) {
-        return sanitizeErrorCode(data["__type"]);
-    }
-};
+const _c = "clean";
+const _e = "email";
+const _f = "from";
+const _oI = "organizationId";
+const _p = "phone";
+const _q = "query";
+const _s = "size";

package/dist-es/runtimeConfig.browser.js

@@ -1,4 +1,6 @@
+import packageInfo from "../package.json";
 import { Sha256 } from "@aws-crypto/sha256-browser";
+import { createDefaultUserAgentProvider } from "@aws-sdk/util-user-agent-browser";
 import { FetchHttpHandler as RequestHandler, streamCollector, } from "@smithy/fetch-http-handler";
 import { calculateBodyLength } from "@smithy/util-body-length-browser";
 import { DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE, } from "@smithy/util-retry";
@@ -15,8 +17,9 @@ export const getRuntimeConfig = (config) => {
         runtime: "browser",
         defaultsMode,
         bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: packageInfo.name, clientVersion: packageInfo.version }),
         maxAttempts: config?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
-        requestHandler: config?.requestHandler ?? new RequestHandler(defaultConfigProvider),
+        requestHandler: RequestHandler.create(config?.requestHandler ?? defaultConfigProvider),
         retryMode: config?.retryMode ?? (async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE),
         sha256: config?.sha256 ?? Sha256,
         streamCollector: config?.streamCollector ?? streamCollector,

package/dist-es/runtimeConfig.js

@@ -1,3 +1,5 @@
+import packageInfo from "../package.json";
+import { NODE_APP_ID_CONFIG_OPTIONS, createDefaultUserAgentProvider, } from "@aws-sdk/util-user-agent-node";
 import { Hash } from "@smithy/hash-node";
 import { NODE_MAX_ATTEMPT_CONFIG_OPTIONS, NODE_RETRY_MODE_CONFIG_OPTIONS, } from "@smithy/middleware-retry";
 import { loadConfig as loadNodeConfig } from "@smithy/node-config-provider";
@@ -19,10 +21,12 @@ export const getRuntimeConfig = (config) => {
         runtime: "node",
         defaultsMode,
         bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
-        maxAttempts: config?.maxAttempts ?? loadNodeConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS),
-        requestHandler: config?.requestHandler ?? new RequestHandler(defaultConfigProvider),
-        retryMode: config?.retryMode ?? loadNodeConfig({ ...NODE_RETRY_MODE_CONFIG_OPTIONS, default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE, }),
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: packageInfo.name, clientVersion: packageInfo.version }),
+        maxAttempts: config?.maxAttempts ?? loadNodeConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+        requestHandler: RequestHandler.create(config?.requestHandler ?? defaultConfigProvider),
+        retryMode: config?.retryMode ?? loadNodeConfig({ ...NODE_RETRY_MODE_CONFIG_OPTIONS, default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE, }, config),
         sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
         streamCollector: config?.streamCollector ?? streamCollector,
+        userAgentAppId: config?.userAgentAppId ?? loadNodeConfig(NODE_APP_ID_CONFIG_OPTIONS, { profile: 'wildix' }),
     };
 };

package/dist-es/runtimeConfig.shared.js

@@ -2,14 +2,16 @@ import { NoOpLogger } from "@smithy/smithy-client";
 import { parseUrl } from "@smithy/url-parser";
 import { fromBase64, toBase64, } from "@smithy/util-base64";
 import { fromUtf8, toUtf8, } from "@smithy/util-utf8";
-export const getRuntimeConfig = (config) => ({
-    apiVersion: "v2",
-    base64Decoder: config?.base64Decoder ?? fromBase64,
-    base64Encoder: config?.base64Encoder ?? toBase64,
-    disableHostPrefix: config?.disableHostPrefix ?? false,
-    extensions: config?.extensions ?? [],
-    logger: config?.logger ?? new NoOpLogger(),
-    urlParser: config?.urlParser ?? parseUrl,
-    utf8Decoder: config?.utf8Decoder ?? fromUtf8,
-    utf8Encoder: config?.utf8Encoder ?? toUtf8,
-});
+export const getRuntimeConfig = (config) => {
+    return {
+        apiVersion: "v2",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        extensions: config?.extensions ?? [],
+        logger: config?.logger ?? new NoOpLogger(),
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};

package/dist-es/runtimeExtensions.js

@@ -1,15 +1,7 @@
 import { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, } from "@smithy/protocol-http";
 import { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, } from "@smithy/smithy-client";
-const asPartial = (t) => t;
 export const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = {
-        ...asPartial(getDefaultExtensionConfiguration(runtimeConfig)),
-        ...asPartial(getHttpHandlerExtensionConfiguration(runtimeConfig)),
-    };
+    const extensionConfiguration = Object.assign(getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig));
     extensions.forEach(extension => extension.configure(extensionConfiguration));
-    return {
-        ...runtimeConfig,
-        ...resolveDefaultRuntimeConfig(extensionConfiguration),
-        ...resolveHttpHandlerRuntimeConfig(extensionConfiguration),
-    };
+    return Object.assign(runtimeConfig, resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration));
 };

package/dist-types/WimCache.d.ts

@@ -5,11 +5,13 @@ import { PutEntitiesToGeneralCacheCommandInput, PutEntitiesToGeneralCacheCommand
 import { SearchEntitiesByListParamsCommandInput, SearchEntitiesByListParamsCommandOutput } from "./commands/SearchEntitiesByListParamsCommand";
 import { SearchEntitiesByParamsCommandInput, SearchEntitiesByParamsCommandOutput } from "./commands/SearchEntitiesByParamsCommand";
 import { SyncCacheCommandInput, SyncCacheCommandOutput } from "./commands/SyncCacheCommand";
+import { UpdateEntitiesWeightCommandInput, UpdateEntitiesWeightCommandOutput } from "./commands/UpdateEntitiesWeightCommand";
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
 export interface WimCache {
     /**
      * @see {@link DeleteEntitiesFromGeneralCacheCommand}
      */
+    deleteEntitiesFromGeneralCache(): Promise<DeleteEntitiesFromGeneralCacheCommandOutput>;
     deleteEntitiesFromGeneralCache(args: DeleteEntitiesFromGeneralCacheCommandInput, options?: __HttpHandlerOptions): Promise<DeleteEntitiesFromGeneralCacheCommandOutput>;
     deleteEntitiesFromGeneralCache(args: DeleteEntitiesFromGeneralCacheCommandInput, cb: (err: any, data?: DeleteEntitiesFromGeneralCacheCommandOutput) => void): void;
     deleteEntitiesFromGeneralCache(args: DeleteEntitiesFromGeneralCacheCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteEntitiesFromGeneralCacheCommandOutput) => void): void;
@@ -22,6 +24,7 @@ export interface WimCache {
     /**
      * @see {@link PutEntitiesToGeneralCacheCommand}
      */
+    putEntitiesToGeneralCache(): Promise<PutEntitiesToGeneralCacheCommandOutput>;
     putEntitiesToGeneralCache(args: PutEntitiesToGeneralCacheCommandInput, options?: __HttpHandlerOptions): Promise<PutEntitiesToGeneralCacheCommandOutput>;
     putEntitiesToGeneralCache(args: PutEntitiesToGeneralCacheCommandInput, cb: (err: any, data?: PutEntitiesToGeneralCacheCommandOutput) => void): void;
     putEntitiesToGeneralCache(args: PutEntitiesToGeneralCacheCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutEntitiesToGeneralCacheCommandOutput) => void): void;
@@ -34,6 +37,7 @@ export interface WimCache {
     /**
      * @see {@link SearchEntitiesByParamsCommand}
      */
+    searchEntitiesByParams(): Promise<SearchEntitiesByParamsCommandOutput>;
     searchEntitiesByParams(args: SearchEntitiesByParamsCommandInput, options?: __HttpHandlerOptions): Promise<SearchEntitiesByParamsCommandOutput>;
     searchEntitiesByParams(args: SearchEntitiesByParamsCommandInput, cb: (err: any, data?: SearchEntitiesByParamsCommandOutput) => void): void;
     searchEntitiesByParams(args: SearchEntitiesByParamsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SearchEntitiesByParamsCommandOutput) => void): void;
@@ -43,6 +47,12 @@ export interface WimCache {
     syncCache(args: SyncCacheCommandInput, options?: __HttpHandlerOptions): Promise<SyncCacheCommandOutput>;
     syncCache(args: SyncCacheCommandInput, cb: (err: any, data?: SyncCacheCommandOutput) => void): void;
     syncCache(args: SyncCacheCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SyncCacheCommandOutput) => void): void;
+    /**
+     * @see {@link UpdateEntitiesWeightCommand}
+     */
+    updateEntitiesWeight(args: UpdateEntitiesWeightCommandInput, options?: __HttpHandlerOptions): Promise<UpdateEntitiesWeightCommandOutput>;
+    updateEntitiesWeight(args: UpdateEntitiesWeightCommandInput, cb: (err: any, data?: UpdateEntitiesWeightCommandOutput) => void): void;
+    updateEntitiesWeight(args: UpdateEntitiesWeightCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateEntitiesWeightCommandOutput) => void): void;
 }
 /**
  * @public