@aws-sdk/client-transfer 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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 = "TransferClient";
-        const commandName = "ImportCertificateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "TransferClient";
+        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 };