@aws-sdk/client-ses 3.183.0 → 3.186.0

package/dist-es/commands/GetIdentityPoliciesCommand.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 { GetIdentityPoliciesRequestFilterSensitiveLog, GetIdentityPoliciesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryGetIdentityPoliciesCommand, serializeAws_queryGetIdentityPoliciesCommand, } from "../protocols/Aws_query";
-export class GetIdentityPoliciesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetIdentityPoliciesCommand = (function (_super) {
+    __extends(GetIdentityPoliciesCommand, _super);
+    function GetIdentityPoliciesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetIdentityPoliciesCommand.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 = "SESClient";
-        const commandName = "GetIdentityPoliciesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetIdentityPoliciesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetIdentityPoliciesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetIdentityPoliciesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetIdentityPoliciesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetIdentityPoliciesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetIdentityPoliciesCommand(output, context);
-    }
-}
+    };
+    return GetIdentityPoliciesCommand;
+}($Command));
+export { GetIdentityPoliciesCommand };

package/dist-es/commands/GetIdentityVerificationAttributesCommand.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 { GetIdentityVerificationAttributesRequestFilterSensitiveLog, GetIdentityVerificationAttributesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryGetIdentityVerificationAttributesCommand, serializeAws_queryGetIdentityVerificationAttributesCommand, } from "../protocols/Aws_query";
-export class GetIdentityVerificationAttributesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetIdentityVerificationAttributesCommand = (function (_super) {
+    __extends(GetIdentityVerificationAttributesCommand, _super);
+    function GetIdentityVerificationAttributesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetIdentityVerificationAttributesCommand.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 = "SESClient";
-        const commandName = "GetIdentityVerificationAttributesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetIdentityVerificationAttributesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetIdentityVerificationAttributesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetIdentityVerificationAttributesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetIdentityVerificationAttributesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetIdentityVerificationAttributesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetIdentityVerificationAttributesCommand(output, context);
-    }
-}
+    };
+    return GetIdentityVerificationAttributesCommand;
+}($Command));
+export { GetIdentityVerificationAttributesCommand };

package/dist-es/commands/GetSendQuotaCommand.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 { GetSendQuotaResponseFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_queryGetSendQuotaCommand, serializeAws_queryGetSendQuotaCommand } from "../protocols/Aws_query";
-export class GetSendQuotaCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetSendQuotaCommand = (function (_super) {
+    __extends(GetSendQuotaCommand, _super);
+    function GetSendQuotaCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetSendQuotaCommand.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 = "SESClient";
-        const commandName = "GetSendQuotaCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (input) => input,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "GetSendQuotaCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: function (input) { return input; },
             outputFilterSensitiveLog: GetSendQuotaResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetSendQuotaCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetSendQuotaCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetSendQuotaCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetSendQuotaCommand(output, context);
-    }
-}
+    };
+    return GetSendQuotaCommand;
+}($Command));
+export { GetSendQuotaCommand };

package/dist-es/commands/GetSendStatisticsCommand.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 { GetSendStatisticsResponseFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_queryGetSendStatisticsCommand, serializeAws_queryGetSendStatisticsCommand, } from "../protocols/Aws_query";
-export class GetSendStatisticsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetSendStatisticsCommand = (function (_super) {
+    __extends(GetSendStatisticsCommand, _super);
+    function GetSendStatisticsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetSendStatisticsCommand.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 = "SESClient";
-        const commandName = "GetSendStatisticsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (input) => input,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "GetSendStatisticsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: function (input) { return input; },
             outputFilterSensitiveLog: GetSendStatisticsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetSendStatisticsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetSendStatisticsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetSendStatisticsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetSendStatisticsCommand(output, context);
-    }
-}
+    };
+    return GetSendStatisticsCommand;
+}($Command));
+export { GetSendStatisticsCommand };

package/dist-es/commands/GetTemplateCommand.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 { GetTemplateRequestFilterSensitiveLog, GetTemplateResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryGetTemplateCommand, serializeAws_queryGetTemplateCommand } from "../protocols/Aws_query";
-export class GetTemplateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetTemplateCommand = (function (_super) {
+    __extends(GetTemplateCommand, _super);
+    function GetTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetTemplateCommand.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 = "SESClient";
-        const commandName = "GetTemplateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "GetTemplateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetTemplateRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetTemplateResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetTemplateCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetTemplateCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetTemplateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetTemplateCommand(output, context);
-    }
-}
+    };
+    return GetTemplateCommand;
+}($Command));
+export { GetTemplateCommand };

package/dist-es/commands/ListConfigurationSetsCommand.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 { ListConfigurationSetsRequestFilterSensitiveLog, ListConfigurationSetsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListConfigurationSetsCommand, serializeAws_queryListConfigurationSetsCommand, } from "../protocols/Aws_query";
-export class ListConfigurationSetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListConfigurationSetsCommand = (function (_super) {
+    __extends(ListConfigurationSetsCommand, _super);
+    function ListConfigurationSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListConfigurationSetsCommand.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 = "SESClient";
-        const commandName = "ListConfigurationSetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "ListConfigurationSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListConfigurationSetsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListConfigurationSetsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListConfigurationSetsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListConfigurationSetsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListConfigurationSetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListConfigurationSetsCommand(output, context);
-    }
-}
+    };
+    return ListConfigurationSetsCommand;
+}($Command));
+export { ListConfigurationSetsCommand };

package/dist-es/commands/ListCustomVerificationEmailTemplatesCommand.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 { ListCustomVerificationEmailTemplatesRequestFilterSensitiveLog, ListCustomVerificationEmailTemplatesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListCustomVerificationEmailTemplatesCommand, serializeAws_queryListCustomVerificationEmailTemplatesCommand, } from "../protocols/Aws_query";
-export class ListCustomVerificationEmailTemplatesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListCustomVerificationEmailTemplatesCommand = (function (_super) {
+    __extends(ListCustomVerificationEmailTemplatesCommand, _super);
+    function ListCustomVerificationEmailTemplatesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListCustomVerificationEmailTemplatesCommand.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 = "SESClient";
-        const commandName = "ListCustomVerificationEmailTemplatesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "ListCustomVerificationEmailTemplatesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListCustomVerificationEmailTemplatesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListCustomVerificationEmailTemplatesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListCustomVerificationEmailTemplatesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListCustomVerificationEmailTemplatesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListCustomVerificationEmailTemplatesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListCustomVerificationEmailTemplatesCommand(output, context);
-    }
-}
+    };
+    return ListCustomVerificationEmailTemplatesCommand;
+}($Command));
+export { ListCustomVerificationEmailTemplatesCommand };

package/dist-es/commands/ListIdentitiesCommand.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 { ListIdentitiesRequestFilterSensitiveLog, ListIdentitiesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListIdentitiesCommand, serializeAws_queryListIdentitiesCommand, } from "../protocols/Aws_query";
-export class ListIdentitiesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListIdentitiesCommand = (function (_super) {
+    __extends(ListIdentitiesCommand, _super);
+    function ListIdentitiesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListIdentitiesCommand.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 = "SESClient";
-        const commandName = "ListIdentitiesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "ListIdentitiesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListIdentitiesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListIdentitiesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListIdentitiesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListIdentitiesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListIdentitiesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListIdentitiesCommand(output, context);
-    }
-}
+    };
+    return ListIdentitiesCommand;
+}($Command));
+export { ListIdentitiesCommand };

package/dist-es/commands/ListIdentityPoliciesCommand.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 { ListIdentityPoliciesRequestFilterSensitiveLog, ListIdentityPoliciesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListIdentityPoliciesCommand, serializeAws_queryListIdentityPoliciesCommand, } from "../protocols/Aws_query";
-export class ListIdentityPoliciesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListIdentityPoliciesCommand = (function (_super) {
+    __extends(ListIdentityPoliciesCommand, _super);
+    function ListIdentityPoliciesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListIdentityPoliciesCommand.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 = "SESClient";
-        const commandName = "ListIdentityPoliciesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "ListIdentityPoliciesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListIdentityPoliciesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListIdentityPoliciesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListIdentityPoliciesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListIdentityPoliciesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListIdentityPoliciesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListIdentityPoliciesCommand(output, context);
-    }
-}
+    };
+    return ListIdentityPoliciesCommand;
+}($Command));
+export { ListIdentityPoliciesCommand };

package/dist-es/commands/ListReceiptFiltersCommand.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 { ListReceiptFiltersRequestFilterSensitiveLog, ListReceiptFiltersResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListReceiptFiltersCommand, serializeAws_queryListReceiptFiltersCommand, } from "../protocols/Aws_query";
-export class ListReceiptFiltersCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListReceiptFiltersCommand = (function (_super) {
+    __extends(ListReceiptFiltersCommand, _super);
+    function ListReceiptFiltersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListReceiptFiltersCommand.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 = "SESClient";
-        const commandName = "ListReceiptFiltersCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "ListReceiptFiltersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListReceiptFiltersRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListReceiptFiltersResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListReceiptFiltersCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListReceiptFiltersCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListReceiptFiltersCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListReceiptFiltersCommand(output, context);
-    }
-}
+    };
+    return ListReceiptFiltersCommand;
+}($Command));
+export { ListReceiptFiltersCommand };