@aws-sdk/client-ses 3.32.0 → 3.36.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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