@aws-sdk/client-acm 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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