@aws-sdk/client-kms 3.32.0 → 3.36.0

package/dist-es/commands/GenerateRandomCommand.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 { GenerateRandomRequest, GenerateRandomResponse } from "../models/models_0";
+import { deserializeAws_json1_1GenerateRandomCommand, serializeAws_json1_1GenerateRandomCommand, } from "../protocols/Aws_json1_1";
+var GenerateRandomCommand = (function (_super) {
+    __extends(GenerateRandomCommand, _super);
+    function GenerateRandomCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GenerateRandomCommand.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 = "GenerateRandomCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GenerateRandomRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GenerateRandomResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    GenerateRandomCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GenerateRandomCommand(output, context);
+    };
+    return GenerateRandomCommand;
+}($Command));
+export { GenerateRandomCommand };

package/{dist/es → dist-es}/commands/GetKeyPolicyCommand.js

@@ -1,48 +1,15 @@
 import { __extends } from "tslib";
-import { GetKeyPolicyRequest, GetKeyPolicyResponse } from "../models/models_0";
-import { deserializeAws_json1_1GetKeyPolicyCommand, serializeAws_json1_1GetKeyPolicyCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Gets a key policy attached to the specified KMS key.</p>
- *          <p>
- *             <b>Cross-account use</b>: No. You cannot perform this operation on a KMS key in a different Amazon Web Services account.</p>
- *
- *          <p>
- *             <b>Required permissions</b>: <a href="https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html">kms:GetKeyPolicy</a> (key policy)</p>
- *          <p>
- *             <b>Related operations</b>: <a>PutKeyPolicy</a>
- *          </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KMSClient, GetKeyPolicyCommand } from "@aws-sdk/client-kms"; // ES Modules import
- * // const { KMSClient, GetKeyPolicyCommand } = require("@aws-sdk/client-kms"); // CommonJS import
- * const client = new KMSClient(config);
- * const command = new GetKeyPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetKeyPolicyCommandInput} for command's `input` shape.
- * @see {@link GetKeyPolicyCommandOutput} for command's `response` shape.
- * @see {@link KMSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var GetKeyPolicyCommand = /** @class */ (function (_super) {
+import { GetKeyPolicyRequest, GetKeyPolicyResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetKeyPolicyCommand, serializeAws_json1_1GetKeyPolicyCommand, } from "../protocols/Aws_json1_1";
+var GetKeyPolicyCommand = (function (_super) {
     __extends(GetKeyPolicyCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function GetKeyPolicyCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     GetKeyPolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -70,4 +37,3 @@ var GetKeyPolicyCommand = /** @class */ (function (_super) {
     return GetKeyPolicyCommand;
 }($Command));
 export { GetKeyPolicyCommand };
-//# sourceMappingURL=GetKeyPolicyCommand.js.map

package/dist-es/commands/GetKeyRotationStatusCommand.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 { GetKeyRotationStatusRequest, GetKeyRotationStatusResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetKeyRotationStatusCommand, serializeAws_json1_1GetKeyRotationStatusCommand, } from "../protocols/Aws_json1_1";
+var GetKeyRotationStatusCommand = (function (_super) {
+    __extends(GetKeyRotationStatusCommand, _super);
+    function GetKeyRotationStatusCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetKeyRotationStatusCommand.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 = "GetKeyRotationStatusCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetKeyRotationStatusRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetKeyRotationStatusResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    GetKeyRotationStatusCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetKeyRotationStatusCommand(output, context);
+    };
+    return GetKeyRotationStatusCommand;
+}($Command));
+export { GetKeyRotationStatusCommand };

package/dist-es/commands/GetParametersForImportCommand.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 { GetParametersForImportRequest, GetParametersForImportResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetParametersForImportCommand, serializeAws_json1_1GetParametersForImportCommand, } from "../protocols/Aws_json1_1";
+var GetParametersForImportCommand = (function (_super) {
+    __extends(GetParametersForImportCommand, _super);
+    function GetParametersForImportCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetParametersForImportCommand.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 = "GetParametersForImportCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetParametersForImportRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetParametersForImportResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    GetParametersForImportCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetParametersForImportCommand(output, context);
+    };
+    return GetParametersForImportCommand;
+}($Command));
+export { GetParametersForImportCommand };

package/dist-es/commands/GetPublicKeyCommand.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 { GetPublicKeyRequest, GetPublicKeyResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetPublicKeyCommand, serializeAws_json1_1GetPublicKeyCommand, } from "../protocols/Aws_json1_1";
+var GetPublicKeyCommand = (function (_super) {
+    __extends(GetPublicKeyCommand, _super);
+    function GetPublicKeyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetPublicKeyCommand.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 = "GetPublicKeyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetPublicKeyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetPublicKeyResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    GetPublicKeyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetPublicKeyCommand(output, context);
+    };
+    return GetPublicKeyCommand;
+}($Command));
+export { GetPublicKeyCommand };

package/dist-es/commands/ImportKeyMaterialCommand.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 { ImportKeyMaterialRequest, ImportKeyMaterialResponse } from "../models/models_0";
+import { deserializeAws_json1_1ImportKeyMaterialCommand, serializeAws_json1_1ImportKeyMaterialCommand, } from "../protocols/Aws_json1_1";
+var ImportKeyMaterialCommand = (function (_super) {
+    __extends(ImportKeyMaterialCommand, _super);
+    function ImportKeyMaterialCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ImportKeyMaterialCommand.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 = "ImportKeyMaterialCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ImportKeyMaterialRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ImportKeyMaterialResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    ImportKeyMaterialCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ImportKeyMaterialCommand(output, context);
+    };
+    return ImportKeyMaterialCommand;
+}($Command));
+export { ImportKeyMaterialCommand };

package/dist-es/commands/ListAliasesCommand.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 { ListAliasesRequest, ListAliasesResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListAliasesCommand, serializeAws_json1_1ListAliasesCommand, } from "../protocols/Aws_json1_1";
+var ListAliasesCommand = (function (_super) {
+    __extends(ListAliasesCommand, _super);
+    function ListAliasesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListAliasesCommand.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 = "ListAliasesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListAliasesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListAliasesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListAliasesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListAliasesCommand(input, context);
+    };
+    ListAliasesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListAliasesCommand(output, context);
+    };
+    return ListAliasesCommand;
+}($Command));
+export { ListAliasesCommand };

package/dist-es/commands/ListGrantsCommand.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 { ListGrantsRequest, ListGrantsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListGrantsCommand, serializeAws_json1_1ListGrantsCommand, } from "../protocols/Aws_json1_1";
+var ListGrantsCommand = (function (_super) {
+    __extends(ListGrantsCommand, _super);
+    function ListGrantsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListGrantsCommand.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 = "ListGrantsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListGrantsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListGrantsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListGrantsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListGrantsCommand(input, context);
+    };
+    ListGrantsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListGrantsCommand(output, context);
+    };
+    return ListGrantsCommand;
+}($Command));
+export { ListGrantsCommand };

package/dist-es/commands/ListKeyPoliciesCommand.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 { ListKeyPoliciesRequest, ListKeyPoliciesResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListKeyPoliciesCommand, serializeAws_json1_1ListKeyPoliciesCommand, } from "../protocols/Aws_json1_1";
+var ListKeyPoliciesCommand = (function (_super) {
+    __extends(ListKeyPoliciesCommand, _super);
+    function ListKeyPoliciesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListKeyPoliciesCommand.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 = "ListKeyPoliciesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListKeyPoliciesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListKeyPoliciesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListKeyPoliciesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListKeyPoliciesCommand(input, context);
+    };
+    ListKeyPoliciesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListKeyPoliciesCommand(output, context);
+    };
+    return ListKeyPoliciesCommand;
+}($Command));
+export { ListKeyPoliciesCommand };

package/dist-es/commands/ListKeysCommand.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 { ListKeysRequest, ListKeysResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListKeysCommand, serializeAws_json1_1ListKeysCommand } from "../protocols/Aws_json1_1";
+var ListKeysCommand = (function (_super) {
+    __extends(ListKeysCommand, _super);
+    function ListKeysCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListKeysCommand.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 = "ListKeysCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListKeysRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListKeysResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListKeysCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListKeysCommand(input, context);
+    };
+    ListKeysCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListKeysCommand(output, context);
+    };
+    return ListKeysCommand;
+}($Command));
+export { ListKeysCommand };

package/dist-es/commands/ListResourceTagsCommand.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 { ListResourceTagsRequest, ListResourceTagsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListResourceTagsCommand, serializeAws_json1_1ListResourceTagsCommand, } from "../protocols/Aws_json1_1";
+var ListResourceTagsCommand = (function (_super) {
+    __extends(ListResourceTagsCommand, _super);
+    function ListResourceTagsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListResourceTagsCommand.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 = "ListResourceTagsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListResourceTagsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListResourceTagsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListResourceTagsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListResourceTagsCommand(input, context);
+    };
+    ListResourceTagsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListResourceTagsCommand(output, context);
+    };
+    return ListResourceTagsCommand;
+}($Command));
+export { ListResourceTagsCommand };

package/dist-es/commands/ListRetirableGrantsCommand.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 { ListGrantsResponse, ListRetirableGrantsRequest } from "../models/models_0";
+import { deserializeAws_json1_1ListRetirableGrantsCommand, serializeAws_json1_1ListRetirableGrantsCommand, } from "../protocols/Aws_json1_1";
+var ListRetirableGrantsCommand = (function (_super) {
+    __extends(ListRetirableGrantsCommand, _super);
+    function ListRetirableGrantsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListRetirableGrantsCommand.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 = "ListRetirableGrantsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListRetirableGrantsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListGrantsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListRetirableGrantsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListRetirableGrantsCommand(input, context);
+    };
+    ListRetirableGrantsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListRetirableGrantsCommand(output, context);
+    };
+    return ListRetirableGrantsCommand;
+}($Command));
+export { ListRetirableGrantsCommand };

package/dist-es/commands/PutKeyPolicyCommand.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 { PutKeyPolicyRequest } from "../models/models_0";
+import { deserializeAws_json1_1PutKeyPolicyCommand, serializeAws_json1_1PutKeyPolicyCommand, } from "../protocols/Aws_json1_1";
+var PutKeyPolicyCommand = (function (_super) {
+    __extends(PutKeyPolicyCommand, _super);
+    function PutKeyPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutKeyPolicyCommand.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 = "PutKeyPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutKeyPolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutKeyPolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1PutKeyPolicyCommand(input, context);
+    };
+    PutKeyPolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1PutKeyPolicyCommand(output, context);
+    };
+    return PutKeyPolicyCommand;
+}($Command));
+export { PutKeyPolicyCommand };

package/dist-es/commands/ReEncryptCommand.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 { ReEncryptRequest, ReEncryptResponse } from "../models/models_0";
+import { deserializeAws_json1_1ReEncryptCommand, serializeAws_json1_1ReEncryptCommand } from "../protocols/Aws_json1_1";
+var ReEncryptCommand = (function (_super) {
+    __extends(ReEncryptCommand, _super);
+    function ReEncryptCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ReEncryptCommand.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 = "ReEncryptCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ReEncryptRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ReEncryptResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ReEncryptCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ReEncryptCommand(input, context);
+    };
+    ReEncryptCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ReEncryptCommand(output, context);
+    };
+    return ReEncryptCommand;
+}($Command));
+export { ReEncryptCommand };

package/dist-es/commands/ReplicateKeyCommand.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 { ReplicateKeyRequest, ReplicateKeyResponse } from "../models/models_0";
+import { deserializeAws_json1_1ReplicateKeyCommand, serializeAws_json1_1ReplicateKeyCommand, } from "../protocols/Aws_json1_1";
+var ReplicateKeyCommand = (function (_super) {
+    __extends(ReplicateKeyCommand, _super);
+    function ReplicateKeyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ReplicateKeyCommand.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 = "ReplicateKeyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ReplicateKeyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ReplicateKeyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ReplicateKeyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ReplicateKeyCommand(input, context);
+    };
+    ReplicateKeyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ReplicateKeyCommand(output, context);
+    };
+    return ReplicateKeyCommand;
+}($Command));
+export { ReplicateKeyCommand };