@aws-sdk/client-kms 3.67.0 → 3.74.0

package/dist-es/KMS.js

@@ -21,6 +21,7 @@ import { GenerateDataKeyCommand, } from "./commands/GenerateDataKeyCommand";
 import { GenerateDataKeyPairCommand, } from "./commands/GenerateDataKeyPairCommand";
 import { GenerateDataKeyPairWithoutPlaintextCommand, } from "./commands/GenerateDataKeyPairWithoutPlaintextCommand";
 import { GenerateDataKeyWithoutPlaintextCommand, } from "./commands/GenerateDataKeyWithoutPlaintextCommand";
+import { GenerateMacCommand } from "./commands/GenerateMacCommand";
 import { GenerateRandomCommand, } from "./commands/GenerateRandomCommand";
 import { GetKeyPolicyCommand, } from "./commands/GetKeyPolicyCommand";
 import { GetKeyRotationStatusCommand, } from "./commands/GetKeyRotationStatusCommand";
@@ -47,6 +48,7 @@ import { UpdateCustomKeyStoreCommand, } from "./commands/UpdateCustomKeyStoreCom
 import { UpdateKeyDescriptionCommand, } from "./commands/UpdateKeyDescriptionCommand";
 import { UpdatePrimaryRegionCommand, } from "./commands/UpdatePrimaryRegionCommand";
 import { VerifyCommand } from "./commands/VerifyCommand";
+import { VerifyMacCommand } from "./commands/VerifyMacCommand";
 import { KMSClient } from "./KMSClient";
 var KMS = (function (_super) {
     __extends(KMS, _super);
@@ -361,6 +363,20 @@ var KMS = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    KMS.prototype.generateMac = function (args, optionsOrCb, cb) {
+        var command = new GenerateMacCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     KMS.prototype.generateRandom = function (args, optionsOrCb, cb) {
         var command = new GenerateRandomCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -725,6 +741,20 @@ var KMS = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    KMS.prototype.verifyMac = function (args, optionsOrCb, cb) {
+        var command = new VerifyMacCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     return KMS;
 }(KMSClient));
 export { KMS };

package/dist-es/commands/GenerateMacCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GenerateMacRequest, GenerateMacResponse } from "../models/models_0";
+import { deserializeAws_json1_1GenerateMacCommand, serializeAws_json1_1GenerateMacCommand, } from "../protocols/Aws_json1_1";
+var GenerateMacCommand = (function (_super) {
+    __extends(GenerateMacCommand, _super);
+    function GenerateMacCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GenerateMacCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KMSClient";
+        var commandName = "GenerateMacCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GenerateMacRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GenerateMacResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GenerateMacCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GenerateMacCommand(input, context);
+    };
+    GenerateMacCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GenerateMacCommand(output, context);
+    };
+    return GenerateMacCommand;
+}($Command));
+export { GenerateMacCommand };

package/dist-es/commands/VerifyMacCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { VerifyMacRequest, VerifyMacResponse } from "../models/models_0";
+import { deserializeAws_json1_1VerifyMacCommand, serializeAws_json1_1VerifyMacCommand } from "../protocols/Aws_json1_1";
+var VerifyMacCommand = (function (_super) {
+    __extends(VerifyMacCommand, _super);
+    function VerifyMacCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    VerifyMacCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KMSClient";
+        var commandName = "VerifyMacCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: VerifyMacRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: VerifyMacResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    VerifyMacCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1VerifyMacCommand(input, context);
+    };
+    VerifyMacCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1VerifyMacCommand(output, context);
+    };
+    return VerifyMacCommand;
+}($Command));
+export { VerifyMacCommand };

package/dist-es/commands/index.js

@@ -20,6 +20,7 @@ export * from "./GenerateDataKeyCommand";
 export * from "./GenerateDataKeyPairCommand";
 export * from "./GenerateDataKeyPairWithoutPlaintextCommand";
 export * from "./GenerateDataKeyWithoutPlaintextCommand";
+export * from "./GenerateMacCommand";
 export * from "./GenerateRandomCommand";
 export * from "./GetKeyPolicyCommand";
 export * from "./GetKeyRotationStatusCommand";
@@ -46,3 +47,4 @@ export * from "./UpdateCustomKeyStoreCommand";
 export * from "./UpdateKeyDescriptionCommand";
 export * from "./UpdatePrimaryRegionCommand";
 export * from "./VerifyCommand";
+export * from "./VerifyMacCommand";

package/dist-es/models/models_0.js

@@ -277,12 +277,14 @@ export var GrantOperation;
     GrantOperation["GenerateDataKeyPair"] = "GenerateDataKeyPair";
     GrantOperation["GenerateDataKeyPairWithoutPlaintext"] = "GenerateDataKeyPairWithoutPlaintext";
     GrantOperation["GenerateDataKeyWithoutPlaintext"] = "GenerateDataKeyWithoutPlaintext";
+    GrantOperation["GenerateMac"] = "GenerateMac";
     GrantOperation["GetPublicKey"] = "GetPublicKey";
     GrantOperation["ReEncryptFrom"] = "ReEncryptFrom";
     GrantOperation["ReEncryptTo"] = "ReEncryptTo";
     GrantOperation["RetireGrant"] = "RetireGrant";
     GrantOperation["Sign"] = "Sign";
     GrantOperation["Verify"] = "Verify";
+    GrantOperation["VerifyMac"] = "VerifyMac";
 })(GrantOperation || (GrantOperation = {}));
 export var CreateGrantRequest;
 (function (CreateGrantRequest) {
@@ -322,6 +324,10 @@ export var CustomerMasterKeySpec;
     CustomerMasterKeySpec["ECC_NIST_P384"] = "ECC_NIST_P384";
     CustomerMasterKeySpec["ECC_NIST_P521"] = "ECC_NIST_P521";
     CustomerMasterKeySpec["ECC_SECG_P256K1"] = "ECC_SECG_P256K1";
+    CustomerMasterKeySpec["HMAC_224"] = "HMAC_224";
+    CustomerMasterKeySpec["HMAC_256"] = "HMAC_256";
+    CustomerMasterKeySpec["HMAC_384"] = "HMAC_384";
+    CustomerMasterKeySpec["HMAC_512"] = "HMAC_512";
     CustomerMasterKeySpec["RSA_2048"] = "RSA_2048";
     CustomerMasterKeySpec["RSA_3072"] = "RSA_3072";
     CustomerMasterKeySpec["RSA_4096"] = "RSA_4096";
@@ -333,6 +339,10 @@ export var KeySpec;
     KeySpec["ECC_NIST_P384"] = "ECC_NIST_P384";
     KeySpec["ECC_NIST_P521"] = "ECC_NIST_P521";
     KeySpec["ECC_SECG_P256K1"] = "ECC_SECG_P256K1";
+    KeySpec["HMAC_224"] = "HMAC_224";
+    KeySpec["HMAC_256"] = "HMAC_256";
+    KeySpec["HMAC_384"] = "HMAC_384";
+    KeySpec["HMAC_512"] = "HMAC_512";
     KeySpec["RSA_2048"] = "RSA_2048";
     KeySpec["RSA_3072"] = "RSA_3072";
     KeySpec["RSA_4096"] = "RSA_4096";
@@ -341,6 +351,7 @@ export var KeySpec;
 export var KeyUsageType;
 (function (KeyUsageType) {
     KeyUsageType["ENCRYPT_DECRYPT"] = "ENCRYPT_DECRYPT";
+    KeyUsageType["GENERATE_VERIFY_MAC"] = "GENERATE_VERIFY_MAC";
     KeyUsageType["SIGN_VERIFY"] = "SIGN_VERIFY";
 })(KeyUsageType || (KeyUsageType = {}));
 export var OriginType;
@@ -384,6 +395,13 @@ export var KeyState;
     KeyState["Unavailable"] = "Unavailable";
     KeyState["Updating"] = "Updating";
 })(KeyState || (KeyState = {}));
+export var MacAlgorithmSpec;
+(function (MacAlgorithmSpec) {
+    MacAlgorithmSpec["HMAC_SHA_224"] = "HMAC_SHA_224";
+    MacAlgorithmSpec["HMAC_SHA_256"] = "HMAC_SHA_256";
+    MacAlgorithmSpec["HMAC_SHA_384"] = "HMAC_SHA_384";
+    MacAlgorithmSpec["HMAC_SHA_512"] = "HMAC_SHA_512";
+})(MacAlgorithmSpec || (MacAlgorithmSpec = {}));
 export var MultiRegionKeyType;
 (function (MultiRegionKeyType) {
     MultiRegionKeyType["PRIMARY"] = "PRIMARY";
@@ -660,6 +678,14 @@ export var GenerateDataKeyWithoutPlaintextResponse;
 (function (GenerateDataKeyWithoutPlaintextResponse) {
     GenerateDataKeyWithoutPlaintextResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GenerateDataKeyWithoutPlaintextResponse || (GenerateDataKeyWithoutPlaintextResponse = {}));
+export var GenerateMacRequest;
+(function (GenerateMacRequest) {
+    GenerateMacRequest.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Message && { Message: SENSITIVE_STRING }))); };
+})(GenerateMacRequest || (GenerateMacRequest = {}));
+export var GenerateMacResponse;
+(function (GenerateMacResponse) {
+    GenerateMacResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GenerateMacResponse || (GenerateMacResponse = {}));
 export var GenerateRandomRequest;
 (function (GenerateRandomRequest) {
     GenerateRandomRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -756,6 +782,18 @@ export var KeyListEntry;
 (function (KeyListEntry) {
     KeyListEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(KeyListEntry || (KeyListEntry = {}));
+var KMSInvalidMacException = (function (_super) {
+    __extends(KMSInvalidMacException, _super);
+    function KMSInvalidMacException(opts) {
+        var _this = _super.call(this, __assign({ name: "KMSInvalidMacException", $fault: "client" }, opts)) || this;
+        _this.name = "KMSInvalidMacException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, KMSInvalidMacException.prototype);
+        return _this;
+    }
+    return KMSInvalidMacException;
+}(__BaseException));
+export { KMSInvalidMacException };
 var KMSInvalidSignatureException = (function (_super) {
     __extends(KMSInvalidSignatureException, _super);
     function KMSInvalidSignatureException(opts) {
@@ -897,3 +935,11 @@ export var VerifyResponse;
 (function (VerifyResponse) {
     VerifyResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(VerifyResponse || (VerifyResponse = {}));
+export var VerifyMacRequest;
+(function (VerifyMacRequest) {
+    VerifyMacRequest.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Message && { Message: SENSITIVE_STRING }))); };
+})(VerifyMacRequest || (VerifyMacRequest = {}));
+export var VerifyMacResponse;
+(function (VerifyMacResponse) {
+    VerifyMacResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(VerifyMacResponse || (VerifyMacResponse = {}));

package/dist-es/protocols/Aws_json1_1.js

@@ -2,7 +2,7 @@ import { __assign, __awaiter, __generator, __read } from "tslib";
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, } from "@aws-sdk/smithy-client";
 import { KMSServiceException as __BaseException } from "../models/KMSServiceException";
-import { AlreadyExistsException, CloudHsmClusterInUseException, CloudHsmClusterInvalidConfigurationException, CloudHsmClusterNotActiveException, CloudHsmClusterNotFoundException, CloudHsmClusterNotRelatedException, CustomKeyStoreHasCMKsException, CustomKeyStoreInvalidStateException, CustomKeyStoreNameInUseException, CustomKeyStoreNotFoundException, DependencyTimeoutException, DisabledException, ExpiredImportTokenException, IncorrectKeyException, IncorrectKeyMaterialException, IncorrectTrustAnchorException, InvalidAliasNameException, InvalidArnException, InvalidCiphertextException, InvalidGrantIdException, InvalidGrantTokenException, InvalidImportTokenException, InvalidKeyUsageException, InvalidMarkerException, KeyUnavailableException, KMSInternalException, KMSInvalidSignatureException, KMSInvalidStateException, LimitExceededException, MalformedPolicyDocumentException, NotFoundException, TagException, UnsupportedOperationException, } from "../models/models_0";
+import { AlreadyExistsException, CloudHsmClusterInUseException, CloudHsmClusterInvalidConfigurationException, CloudHsmClusterNotActiveException, CloudHsmClusterNotFoundException, CloudHsmClusterNotRelatedException, CustomKeyStoreHasCMKsException, CustomKeyStoreInvalidStateException, CustomKeyStoreNameInUseException, CustomKeyStoreNotFoundException, DependencyTimeoutException, DisabledException, ExpiredImportTokenException, IncorrectKeyException, IncorrectKeyMaterialException, IncorrectTrustAnchorException, InvalidAliasNameException, InvalidArnException, InvalidCiphertextException, InvalidGrantIdException, InvalidGrantTokenException, InvalidImportTokenException, InvalidKeyUsageException, InvalidMarkerException, KeyUnavailableException, KMSInternalException, KMSInvalidMacException, KMSInvalidSignatureException, KMSInvalidStateException, LimitExceededException, MalformedPolicyDocumentException, NotFoundException, TagException, UnsupportedOperationException, } from "../models/models_0";
 export var serializeAws_json1_1CancelKeyDeletionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -245,6 +245,17 @@ export var serializeAws_json1_1GenerateDataKeyWithoutPlaintextCommand = function
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_json1_1GenerateMacCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.1",
+            "x-amz-target": "TrentService.GenerateMac",
+        };
+        body = JSON.stringify(serializeAws_json1_1GenerateMacRequest(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_json1_1GenerateRandomCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -531,6 +542,17 @@ export var serializeAws_json1_1VerifyCommand = function (input, context) { retur
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_json1_1VerifyMacCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.1",
+            "x-amz-target": "TrentService.VerifyMac",
+        };
+        body = JSON.stringify(serializeAws_json1_1VerifyMacRequest(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var deserializeAws_json1_1CancelKeyDeletionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -2115,6 +2137,80 @@ var deserializeAws_json1_1GenerateDataKeyWithoutPlaintextCommandError = function
         }
     });
 }); };
+export var deserializeAws_json1_1GenerateMacCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_1GenerateMacCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_1GenerateMacResponse(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_1GenerateMacCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = "UnknownError";
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "DisabledException": return [3, 2];
+                    case "com.amazonaws.kms#DisabledException": return [3, 2];
+                    case "InvalidGrantTokenException": return [3, 4];
+                    case "com.amazonaws.kms#InvalidGrantTokenException": return [3, 4];
+                    case "InvalidKeyUsageException": return [3, 6];
+                    case "com.amazonaws.kms#InvalidKeyUsageException": return [3, 6];
+                    case "KeyUnavailableException": return [3, 8];
+                    case "com.amazonaws.kms#KeyUnavailableException": return [3, 8];
+                    case "KMSInternalException": return [3, 10];
+                    case "com.amazonaws.kms#KMSInternalException": return [3, 10];
+                    case "KMSInvalidStateException": return [3, 12];
+                    case "com.amazonaws.kms#KMSInvalidStateException": return [3, 12];
+                    case "NotFoundException": return [3, 14];
+                    case "com.amazonaws.kms#NotFoundException": return [3, 14];
+                }
+                return [3, 16];
+            case 2: return [4, deserializeAws_json1_1DisabledExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_1InvalidGrantTokenExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_1InvalidKeyUsageExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_json1_1KeyUnavailableExceptionResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_json1_1KMSInternalExceptionResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_json1_1KMSInvalidStateExceptionResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
+            case 15: throw _d.sent();
+            case 16:
+                parsedBody = parsedOutput.body;
+                response = new __BaseException({
+                    name: parsedBody.code || parsedBody.Code || errorCode,
+                    $fault: "client",
+                    $metadata: deserializeMetadata(output),
+                });
+                throw __decorateServiceException(response, parsedBody);
+        }
+    });
+}); };
 export var deserializeAws_json1_1GenerateRandomCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -3983,6 +4079,84 @@ var deserializeAws_json1_1VerifyCommandError = function (output, context) { retu
         }
     });
 }); };
+export var deserializeAws_json1_1VerifyMacCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_1VerifyMacCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_1VerifyMacResponse(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_1VerifyMacCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = "UnknownError";
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "DisabledException": return [3, 2];
+                    case "com.amazonaws.kms#DisabledException": return [3, 2];
+                    case "InvalidGrantTokenException": return [3, 4];
+                    case "com.amazonaws.kms#InvalidGrantTokenException": return [3, 4];
+                    case "InvalidKeyUsageException": return [3, 6];
+                    case "com.amazonaws.kms#InvalidKeyUsageException": return [3, 6];
+                    case "KeyUnavailableException": return [3, 8];
+                    case "com.amazonaws.kms#KeyUnavailableException": return [3, 8];
+                    case "KMSInternalException": return [3, 10];
+                    case "com.amazonaws.kms#KMSInternalException": return [3, 10];
+                    case "KMSInvalidMacException": return [3, 12];
+                    case "com.amazonaws.kms#KMSInvalidMacException": return [3, 12];
+                    case "KMSInvalidStateException": return [3, 14];
+                    case "com.amazonaws.kms#KMSInvalidStateException": return [3, 14];
+                    case "NotFoundException": return [3, 16];
+                    case "com.amazonaws.kms#NotFoundException": return [3, 16];
+                }
+                return [3, 18];
+            case 2: return [4, deserializeAws_json1_1DisabledExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_1InvalidGrantTokenExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_1InvalidKeyUsageExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_json1_1KeyUnavailableExceptionResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_json1_1KMSInternalExceptionResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_json1_1KMSInvalidMacExceptionResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14: return [4, deserializeAws_json1_1KMSInvalidStateExceptionResponse(parsedOutput, context)];
+            case 15: throw _d.sent();
+            case 16: return [4, deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context)];
+            case 17: throw _d.sent();
+            case 18:
+                parsedBody = parsedOutput.body;
+                response = new __BaseException({
+                    name: parsedBody.code || parsedBody.Code || errorCode,
+                    $fault: "client",
+                    $metadata: deserializeMetadata(output),
+                });
+                throw __decorateServiceException(response, parsedBody);
+        }
+    });
+}); };
 var deserializeAws_json1_1AlreadyExistsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
     var body, deserialized, exception;
     return __generator(this, function (_a) {
@@ -4217,6 +4391,15 @@ var deserializeAws_json1_1KMSInternalExceptionResponse = function (parsedOutput,
         return [2, __decorateServiceException(exception, body)];
     });
 }); };
+var deserializeAws_json1_1KMSInvalidMacExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_1KMSInvalidMacException(body, context);
+        exception = new KMSInvalidMacException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
 var deserializeAws_json1_1KMSInvalidSignatureExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
     var body, deserialized, exception;
     return __generator(this, function (_a) {
@@ -4404,6 +4587,10 @@ var serializeAws_json1_1GenerateDataKeyWithoutPlaintextRequest = function (input
     })), (input.GrantTokens !== undefined &&
         input.GrantTokens !== null && { GrantTokens: serializeAws_json1_1GrantTokenList(input.GrantTokens, context) })), (input.KeyId !== undefined && input.KeyId !== null && { KeyId: input.KeyId })), (input.KeySpec !== undefined && input.KeySpec !== null && { KeySpec: input.KeySpec })), (input.NumberOfBytes !== undefined && input.NumberOfBytes !== null && { NumberOfBytes: input.NumberOfBytes }));
 };
+var serializeAws_json1_1GenerateMacRequest = function (input, context) {
+    return __assign(__assign(__assign(__assign({}, (input.GrantTokens !== undefined &&
+        input.GrantTokens !== null && { GrantTokens: serializeAws_json1_1GrantTokenList(input.GrantTokens, context) })), (input.KeyId !== undefined && input.KeyId !== null && { KeyId: input.KeyId })), (input.MacAlgorithm !== undefined && input.MacAlgorithm !== null && { MacAlgorithm: input.MacAlgorithm })), (input.Message !== undefined && input.Message !== null && { Message: context.base64Encoder(input.Message) }));
+};
 var serializeAws_json1_1GenerateRandomRequest = function (input, context) {
     return __assign(__assign({}, (input.CustomKeyStoreId !== undefined &&
         input.CustomKeyStoreId !== null && { CustomKeyStoreId: input.CustomKeyStoreId })), (input.NumberOfBytes !== undefined && input.NumberOfBytes !== null && { NumberOfBytes: input.NumberOfBytes }));
@@ -4570,6 +4757,10 @@ var serializeAws_json1_1UpdateKeyDescriptionRequest = function (input, context)
 var serializeAws_json1_1UpdatePrimaryRegionRequest = function (input, context) {
     return __assign(__assign({}, (input.KeyId !== undefined && input.KeyId !== null && { KeyId: input.KeyId })), (input.PrimaryRegion !== undefined && input.PrimaryRegion !== null && { PrimaryRegion: input.PrimaryRegion }));
 };
+var serializeAws_json1_1VerifyMacRequest = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign({}, (input.GrantTokens !== undefined &&
+        input.GrantTokens !== null && { GrantTokens: serializeAws_json1_1GrantTokenList(input.GrantTokens, context) })), (input.KeyId !== undefined && input.KeyId !== null && { KeyId: input.KeyId })), (input.Mac !== undefined && input.Mac !== null && { Mac: context.base64Encoder(input.Mac) })), (input.MacAlgorithm !== undefined && input.MacAlgorithm !== null && { MacAlgorithm: input.MacAlgorithm })), (input.Message !== undefined && input.Message !== null && { Message: context.base64Encoder(input.Message) }));
+};
 var serializeAws_json1_1VerifyRequest = function (input, context) {
     return __assign(__assign(__assign(__assign(__assign(__assign({}, (input.GrantTokens !== undefined &&
         input.GrantTokens !== null && { GrantTokens: serializeAws_json1_1GrantTokenList(input.GrantTokens, context) })), (input.KeyId !== undefined && input.KeyId !== null && { KeyId: input.KeyId })), (input.Message !== undefined && input.Message !== null && { Message: context.base64Encoder(input.Message) })), (input.MessageType !== undefined && input.MessageType !== null && { MessageType: input.MessageType })), (input.Signature !== undefined &&
@@ -4814,6 +5005,13 @@ var deserializeAws_json1_1GenerateDataKeyWithoutPlaintextResponse = function (ou
         KeyId: __expectString(output.KeyId),
     };
 };
+var deserializeAws_json1_1GenerateMacResponse = function (output, context) {
+    return {
+        KeyId: __expectString(output.KeyId),
+        Mac: output.Mac !== undefined && output.Mac !== null ? context.base64Decoder(output.Mac) : undefined,
+        MacAlgorithm: __expectString(output.MacAlgorithm),
+    };
+};
 var deserializeAws_json1_1GenerateRandomResponse = function (output, context) {
     return {
         Plaintext: output.Plaintext !== undefined && output.Plaintext !== null ? context.base64Decoder(output.Plaintext) : undefined,
@@ -5006,6 +5204,9 @@ var deserializeAws_json1_1KeyMetadata = function (output, context) {
         KeySpec: __expectString(output.KeySpec),
         KeyState: __expectString(output.KeyState),
         KeyUsage: __expectString(output.KeyUsage),
+        MacAlgorithms: output.MacAlgorithms !== undefined && output.MacAlgorithms !== null
+            ? deserializeAws_json1_1MacAlgorithmSpecList(output.MacAlgorithms, context)
+            : undefined,
         MultiRegion: __expectBoolean(output.MultiRegion),
         MultiRegionConfiguration: output.MultiRegionConfiguration !== undefined && output.MultiRegionConfiguration !== null
             ? deserializeAws_json1_1MultiRegionConfiguration(output.MultiRegionConfiguration, context)
@@ -5030,6 +5231,11 @@ var deserializeAws_json1_1KMSInternalException = function (output, context) {
         message: __expectString(output.message),
     };
 };
+var deserializeAws_json1_1KMSInvalidMacException = function (output, context) {
+    return {
+        message: __expectString(output.message),
+    };
+};
 var deserializeAws_json1_1KMSInvalidSignatureException = function (output, context) {
     return {
         message: __expectString(output.message),
@@ -5090,6 +5296,17 @@ var deserializeAws_json1_1ListResourceTagsResponse = function (output, context)
         Truncated: __expectBoolean(output.Truncated),
     };
 };
+var deserializeAws_json1_1MacAlgorithmSpecList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
 var deserializeAws_json1_1MalformedPolicyDocumentException = function (output, context) {
     return {
         message: __expectString(output.message),
@@ -5219,6 +5436,13 @@ var deserializeAws_json1_1UnsupportedOperationException = function (output, cont
 var deserializeAws_json1_1UpdateCustomKeyStoreResponse = function (output, context) {
     return {};
 };
+var deserializeAws_json1_1VerifyMacResponse = function (output, context) {
+    return {
+        KeyId: __expectString(output.KeyId),
+        MacAlgorithm: __expectString(output.MacAlgorithm),
+        MacValid: __expectBoolean(output.MacValid),
+    };
+};
 var deserializeAws_json1_1VerifyResponse = function (output, context) {
     return {
         KeyId: __expectString(output.KeyId),