@aws-sdk/client-transfer 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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