@aws-sdk/client-kms 3.183.0 → 3.185.0

package/dist-es/commands/GenerateDataKeyPairCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GenerateDataKeyPairRequestFilterSensitiveLog, GenerateDataKeyPairResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GenerateDataKeyPairCommand, serializeAws_json1_1GenerateDataKeyPairCommand, } from "../protocols/Aws_json1_1";
-export class GenerateDataKeyPairCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GenerateDataKeyPairCommand = (function (_super) {
+    __extends(GenerateDataKeyPairCommand, _super);
+    function GenerateDataKeyPairCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GenerateDataKeyPairCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "KMSClient";
-        const commandName = "GenerateDataKeyPairCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KMSClient";
+        var commandName = "GenerateDataKeyPairCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GenerateDataKeyPairRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GenerateDataKeyPairResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GenerateDataKeyPairCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GenerateDataKeyPairCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GenerateDataKeyPairCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GenerateDataKeyPairCommand(output, context);
-    }
-}
+    };
+    return GenerateDataKeyPairCommand;
+}($Command));
+export { GenerateDataKeyPairCommand };

package/dist-es/commands/GenerateDataKeyPairWithoutPlaintextCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GenerateDataKeyPairWithoutPlaintextRequestFilterSensitiveLog, GenerateDataKeyPairWithoutPlaintextResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GenerateDataKeyPairWithoutPlaintextCommand, serializeAws_json1_1GenerateDataKeyPairWithoutPlaintextCommand, } from "../protocols/Aws_json1_1";
-export class GenerateDataKeyPairWithoutPlaintextCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GenerateDataKeyPairWithoutPlaintextCommand = (function (_super) {
+    __extends(GenerateDataKeyPairWithoutPlaintextCommand, _super);
+    function GenerateDataKeyPairWithoutPlaintextCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GenerateDataKeyPairWithoutPlaintextCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "KMSClient";
-        const commandName = "GenerateDataKeyPairWithoutPlaintextCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KMSClient";
+        var commandName = "GenerateDataKeyPairWithoutPlaintextCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GenerateDataKeyPairWithoutPlaintextRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GenerateDataKeyPairWithoutPlaintextResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GenerateDataKeyPairWithoutPlaintextCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GenerateDataKeyPairWithoutPlaintextCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GenerateDataKeyPairWithoutPlaintextCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GenerateDataKeyPairWithoutPlaintextCommand(output, context);
-    }
-}
+    };
+    return GenerateDataKeyPairWithoutPlaintextCommand;
+}($Command));
+export { GenerateDataKeyPairWithoutPlaintextCommand };

package/dist-es/commands/GenerateDataKeyWithoutPlaintextCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GenerateDataKeyWithoutPlaintextRequestFilterSensitiveLog, GenerateDataKeyWithoutPlaintextResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GenerateDataKeyWithoutPlaintextCommand, serializeAws_json1_1GenerateDataKeyWithoutPlaintextCommand, } from "../protocols/Aws_json1_1";
-export class GenerateDataKeyWithoutPlaintextCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GenerateDataKeyWithoutPlaintextCommand = (function (_super) {
+    __extends(GenerateDataKeyWithoutPlaintextCommand, _super);
+    function GenerateDataKeyWithoutPlaintextCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GenerateDataKeyWithoutPlaintextCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "KMSClient";
-        const commandName = "GenerateDataKeyWithoutPlaintextCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KMSClient";
+        var commandName = "GenerateDataKeyWithoutPlaintextCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GenerateDataKeyWithoutPlaintextRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GenerateDataKeyWithoutPlaintextResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GenerateDataKeyWithoutPlaintextCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GenerateDataKeyWithoutPlaintextCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GenerateDataKeyWithoutPlaintextCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GenerateDataKeyWithoutPlaintextCommand(output, context);
-    }
-}
+    };
+    return GenerateDataKeyWithoutPlaintextCommand;
+}($Command));
+export { GenerateDataKeyWithoutPlaintextCommand };

package/dist-es/commands/GenerateMacCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GenerateMacRequestFilterSensitiveLog, GenerateMacResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GenerateMacCommand, serializeAws_json1_1GenerateMacCommand, } from "../protocols/Aws_json1_1";
-export class GenerateMacCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GenerateMacCommand = (function (_super) {
+    __extends(GenerateMacCommand, _super);
+    function GenerateMacCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GenerateMacCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "KMSClient";
-        const commandName = "GenerateMacCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GenerateMacRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GenerateMacResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    GenerateMacCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GenerateMacCommand(output, context);
-    }
-}
+    };
+    return GenerateMacCommand;
+}($Command));
+export { GenerateMacCommand };

package/dist-es/commands/GenerateRandomCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GenerateRandomRequestFilterSensitiveLog, GenerateRandomResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GenerateRandomCommand, serializeAws_json1_1GenerateRandomCommand, } from "../protocols/Aws_json1_1";
-export class GenerateRandomCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GenerateRandomCommand = (function (_super) {
+    __extends(GenerateRandomCommand, _super);
+    function GenerateRandomCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GenerateRandomCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "KMSClient";
-        const commandName = "GenerateRandomCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KMSClient";
+        var commandName = "GenerateRandomCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GenerateRandomRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GenerateRandomResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GenerateRandomCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GenerateRandomCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GenerateRandomCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GenerateRandomCommand(output, context);
-    }
-}
+    };
+    return GenerateRandomCommand;
+}($Command));
+export { GenerateRandomCommand };

package/dist-es/commands/GetKeyPolicyCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetKeyPolicyRequestFilterSensitiveLog, GetKeyPolicyResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetKeyPolicyCommand, serializeAws_json1_1GetKeyPolicyCommand, } from "../protocols/Aws_json1_1";
-export class GetKeyPolicyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetKeyPolicyCommand = (function (_super) {
+    __extends(GetKeyPolicyCommand, _super);
+    function GetKeyPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetKeyPolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "KMSClient";
-        const commandName = "GetKeyPolicyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KMSClient";
+        var commandName = "GetKeyPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetKeyPolicyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetKeyPolicyResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetKeyPolicyCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetKeyPolicyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetKeyPolicyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetKeyPolicyCommand(output, context);
-    }
-}
+    };
+    return GetKeyPolicyCommand;
+}($Command));
+export { GetKeyPolicyCommand };

package/dist-es/commands/GetKeyRotationStatusCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetKeyRotationStatusRequestFilterSensitiveLog, GetKeyRotationStatusResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetKeyRotationStatusCommand, serializeAws_json1_1GetKeyRotationStatusCommand, } from "../protocols/Aws_json1_1";
-export class GetKeyRotationStatusCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetKeyRotationStatusCommand = (function (_super) {
+    __extends(GetKeyRotationStatusCommand, _super);
+    function GetKeyRotationStatusCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetKeyRotationStatusCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "KMSClient";
-        const commandName = "GetKeyRotationStatusCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KMSClient";
+        var commandName = "GetKeyRotationStatusCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetKeyRotationStatusRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetKeyRotationStatusResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetKeyRotationStatusCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetKeyRotationStatusCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetKeyRotationStatusCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetKeyRotationStatusCommand(output, context);
-    }
-}
+    };
+    return GetKeyRotationStatusCommand;
+}($Command));
+export { GetKeyRotationStatusCommand };

package/dist-es/commands/GetParametersForImportCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetParametersForImportRequestFilterSensitiveLog, GetParametersForImportResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetParametersForImportCommand, serializeAws_json1_1GetParametersForImportCommand, } from "../protocols/Aws_json1_1";
-export class GetParametersForImportCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetParametersForImportCommand = (function (_super) {
+    __extends(GetParametersForImportCommand, _super);
+    function GetParametersForImportCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetParametersForImportCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "KMSClient";
-        const commandName = "GetParametersForImportCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KMSClient";
+        var commandName = "GetParametersForImportCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetParametersForImportRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetParametersForImportResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetParametersForImportCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetParametersForImportCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetParametersForImportCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetParametersForImportCommand(output, context);
-    }
-}
+    };
+    return GetParametersForImportCommand;
+}($Command));
+export { GetParametersForImportCommand };

package/dist-es/commands/GetPublicKeyCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetPublicKeyRequestFilterSensitiveLog, GetPublicKeyResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetPublicKeyCommand, serializeAws_json1_1GetPublicKeyCommand, } from "../protocols/Aws_json1_1";
-export class GetPublicKeyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetPublicKeyCommand = (function (_super) {
+    __extends(GetPublicKeyCommand, _super);
+    function GetPublicKeyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetPublicKeyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "KMSClient";
-        const commandName = "GetPublicKeyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KMSClient";
+        var commandName = "GetPublicKeyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetPublicKeyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetPublicKeyResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetPublicKeyCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetPublicKeyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetPublicKeyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetPublicKeyCommand(output, context);
-    }
-}
+    };
+    return GetPublicKeyCommand;
+}($Command));
+export { GetPublicKeyCommand };

package/dist-es/commands/ImportKeyMaterialCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ImportKeyMaterialRequestFilterSensitiveLog, ImportKeyMaterialResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ImportKeyMaterialCommand, serializeAws_json1_1ImportKeyMaterialCommand, } from "../protocols/Aws_json1_1";
-export class ImportKeyMaterialCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ImportKeyMaterialCommand = (function (_super) {
+    __extends(ImportKeyMaterialCommand, _super);
+    function ImportKeyMaterialCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ImportKeyMaterialCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "KMSClient";
-        const commandName = "ImportKeyMaterialCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "KMSClient";
+        var commandName = "ImportKeyMaterialCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ImportKeyMaterialRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ImportKeyMaterialResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ImportKeyMaterialCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ImportKeyMaterialCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ImportKeyMaterialCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ImportKeyMaterialCommand(output, context);
-    }
-}
+    };
+    return ImportKeyMaterialCommand;
+}($Command));
+export { ImportKeyMaterialCommand };