@aws-sdk/client-transfer 3.1068.0 → 3.1069.0

package/dist-cjs/index.js

@@ -1,18 +1,21 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var TransferServiceException = require('./models/TransferServiceException');
+var __exportStar = (m, e) => { Object.assign(e, m); };
+const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
+const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
+exports.$Command = Command;
+exports.__Client = Client;
+const { resolveRegionConfig } = require("@smithy/core/config");
+const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveHttpAuthSchemeConfig, defaultTransferHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { CreateAccess$, CreateAgreement$, CreateConnector$, CreateProfile$, CreateServer$, CreateUser$, CreateWebApp$, CreateWorkflow$, DeleteAccess$, DeleteAgreement$, DeleteCertificate$, DeleteConnector$, DeleteHostKey$, DeleteProfile$, DeleteServer$, DeleteSshPublicKey$, DeleteUser$, DeleteWebApp$, DeleteWebAppCustomization$, DeleteWorkflow$, DescribeAccess$, DescribeAgreement$, DescribeCertificate$, DescribeConnector$, DescribeExecution$, DescribeHostKey$, DescribeProfile$, DescribeSecurityPolicy$, DescribeServer$, DescribeUser$, DescribeWebApp$, DescribeWebAppCustomization$, DescribeWorkflow$, ImportCertificate$, ImportHostKey$, ImportSshPublicKey$, ListAccesses$, ListAgreements$, ListCertificates$, ListConnectors$, ListExecutions$, ListFileTransferResults$, ListHostKeys$, ListProfiles$, ListSecurityPolicies$, ListServers$, ListTagsForResource$, ListUsers$, ListWebApps$, ListWorkflows$, SendWorkflowStepState$, StartDirectoryListing$, StartFileTransfer$, StartRemoteDelete$, StartRemoteMove$, StartServer$, StopServer$, TagResource$, TestConnection$, TestIdentityProvider$, UntagResource$, UpdateAccess$, UpdateAgreement$, UpdateCertificate$, UpdateConnector$, UpdateHostKey$, UpdateProfile$, UpdateServer$, UpdateUser$, UpdateWebApp$, UpdateWebAppCustomization$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { TransferServiceException } = require("./models/TransferServiceException");
+exports.TransferServiceException = TransferServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,935 +71,935 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class TransferClient extends client.Client {
+class TransferClient extends Client {
     config;
     constructor(...[configuration]) {
-        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        const _config_0 = getRuntimeConfig(configuration || {});
         super(_config_0);
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
-        const _config_2 = client$1.resolveUserAgentConfig(_config_1);
-        const _config_3 = retry.resolveRetryConfig(_config_2);
-        const _config_4 = config.resolveRegionConfig(_config_3);
-        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
-        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
-        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
-        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
-        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(retry.getRetryPlugin(this.config));
-        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
-        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
-        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
-            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultTransferHttpAuthSchemeParametersProvider,
-            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultTransferHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
     }
 }
 
-class CreateAccessCommand extends client.Command
+class CreateAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "CreateAccess", {})
     .n("TransferClient", "CreateAccessCommand")
-    .sc(schemas_0.CreateAccess$)
+    .sc(CreateAccess$)
     .build() {
 }
 
-class CreateAgreementCommand extends client.Command
+class CreateAgreementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "CreateAgreement", {})
     .n("TransferClient", "CreateAgreementCommand")
-    .sc(schemas_0.CreateAgreement$)
+    .sc(CreateAgreement$)
     .build() {
 }
 
-class CreateConnectorCommand extends client.Command
+class CreateConnectorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "CreateConnector", {})
     .n("TransferClient", "CreateConnectorCommand")
-    .sc(schemas_0.CreateConnector$)
+    .sc(CreateConnector$)
     .build() {
 }
 
-class CreateProfileCommand extends client.Command
+class CreateProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "CreateProfile", {})
     .n("TransferClient", "CreateProfileCommand")
-    .sc(schemas_0.CreateProfile$)
+    .sc(CreateProfile$)
     .build() {
 }
 
-class CreateServerCommand extends client.Command
+class CreateServerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "CreateServer", {})
     .n("TransferClient", "CreateServerCommand")
-    .sc(schemas_0.CreateServer$)
+    .sc(CreateServer$)
     .build() {
 }
 
-class CreateUserCommand extends client.Command
+class CreateUserCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "CreateUser", {})
     .n("TransferClient", "CreateUserCommand")
-    .sc(schemas_0.CreateUser$)
+    .sc(CreateUser$)
     .build() {
 }
 
-class CreateWebAppCommand extends client.Command
+class CreateWebAppCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "CreateWebApp", {})
     .n("TransferClient", "CreateWebAppCommand")
-    .sc(schemas_0.CreateWebApp$)
+    .sc(CreateWebApp$)
     .build() {
 }
 
-class CreateWorkflowCommand extends client.Command
+class CreateWorkflowCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "CreateWorkflow", {})
     .n("TransferClient", "CreateWorkflowCommand")
-    .sc(schemas_0.CreateWorkflow$)
+    .sc(CreateWorkflow$)
     .build() {
 }
 
-class DeleteAccessCommand extends client.Command
+class DeleteAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteAccess", {})
     .n("TransferClient", "DeleteAccessCommand")
-    .sc(schemas_0.DeleteAccess$)
+    .sc(DeleteAccess$)
     .build() {
 }
 
-class DeleteAgreementCommand extends client.Command
+class DeleteAgreementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteAgreement", {})
     .n("TransferClient", "DeleteAgreementCommand")
-    .sc(schemas_0.DeleteAgreement$)
+    .sc(DeleteAgreement$)
     .build() {
 }
 
-class DeleteCertificateCommand extends client.Command
+class DeleteCertificateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteCertificate", {})
     .n("TransferClient", "DeleteCertificateCommand")
-    .sc(schemas_0.DeleteCertificate$)
+    .sc(DeleteCertificate$)
     .build() {
 }
 
-class DeleteConnectorCommand extends client.Command
+class DeleteConnectorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteConnector", {})
     .n("TransferClient", "DeleteConnectorCommand")
-    .sc(schemas_0.DeleteConnector$)
+    .sc(DeleteConnector$)
     .build() {
 }
 
-class DeleteHostKeyCommand extends client.Command
+class DeleteHostKeyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteHostKey", {})
     .n("TransferClient", "DeleteHostKeyCommand")
-    .sc(schemas_0.DeleteHostKey$)
+    .sc(DeleteHostKey$)
     .build() {
 }
 
-class DeleteProfileCommand extends client.Command
+class DeleteProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteProfile", {})
     .n("TransferClient", "DeleteProfileCommand")
-    .sc(schemas_0.DeleteProfile$)
+    .sc(DeleteProfile$)
     .build() {
 }
 
-class DeleteServerCommand extends client.Command
+class DeleteServerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteServer", {})
     .n("TransferClient", "DeleteServerCommand")
-    .sc(schemas_0.DeleteServer$)
+    .sc(DeleteServer$)
     .build() {
 }
 
-class DeleteSshPublicKeyCommand extends client.Command
+class DeleteSshPublicKeyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteSshPublicKey", {})
     .n("TransferClient", "DeleteSshPublicKeyCommand")
-    .sc(schemas_0.DeleteSshPublicKey$)
+    .sc(DeleteSshPublicKey$)
     .build() {
 }
 
-class DeleteUserCommand extends client.Command
+class DeleteUserCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteUser", {})
     .n("TransferClient", "DeleteUserCommand")
-    .sc(schemas_0.DeleteUser$)
+    .sc(DeleteUser$)
     .build() {
 }
 
-class DeleteWebAppCommand extends client.Command
+class DeleteWebAppCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteWebApp", {})
     .n("TransferClient", "DeleteWebAppCommand")
-    .sc(schemas_0.DeleteWebApp$)
+    .sc(DeleteWebApp$)
     .build() {
 }
 
-class DeleteWebAppCustomizationCommand extends client.Command
+class DeleteWebAppCustomizationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteWebAppCustomization", {})
     .n("TransferClient", "DeleteWebAppCustomizationCommand")
-    .sc(schemas_0.DeleteWebAppCustomization$)
+    .sc(DeleteWebAppCustomization$)
     .build() {
 }
 
-class DeleteWorkflowCommand extends client.Command
+class DeleteWorkflowCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DeleteWorkflow", {})
     .n("TransferClient", "DeleteWorkflowCommand")
-    .sc(schemas_0.DeleteWorkflow$)
+    .sc(DeleteWorkflow$)
     .build() {
 }
 
-class DescribeAccessCommand extends client.Command
+class DescribeAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeAccess", {})
     .n("TransferClient", "DescribeAccessCommand")
-    .sc(schemas_0.DescribeAccess$)
+    .sc(DescribeAccess$)
     .build() {
 }
 
-class DescribeAgreementCommand extends client.Command
+class DescribeAgreementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeAgreement", {})
     .n("TransferClient", "DescribeAgreementCommand")
-    .sc(schemas_0.DescribeAgreement$)
+    .sc(DescribeAgreement$)
     .build() {
 }
 
-class DescribeCertificateCommand extends client.Command
+class DescribeCertificateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeCertificate", {})
     .n("TransferClient", "DescribeCertificateCommand")
-    .sc(schemas_0.DescribeCertificate$)
+    .sc(DescribeCertificate$)
     .build() {
 }
 
-class DescribeConnectorCommand extends client.Command
+class DescribeConnectorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeConnector", {})
     .n("TransferClient", "DescribeConnectorCommand")
-    .sc(schemas_0.DescribeConnector$)
+    .sc(DescribeConnector$)
     .build() {
 }
 
-class DescribeExecutionCommand extends client.Command
+class DescribeExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeExecution", {})
     .n("TransferClient", "DescribeExecutionCommand")
-    .sc(schemas_0.DescribeExecution$)
+    .sc(DescribeExecution$)
     .build() {
 }
 
-class DescribeHostKeyCommand extends client.Command
+class DescribeHostKeyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeHostKey", {})
     .n("TransferClient", "DescribeHostKeyCommand")
-    .sc(schemas_0.DescribeHostKey$)
+    .sc(DescribeHostKey$)
     .build() {
 }
 
-class DescribeProfileCommand extends client.Command
+class DescribeProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeProfile", {})
     .n("TransferClient", "DescribeProfileCommand")
-    .sc(schemas_0.DescribeProfile$)
+    .sc(DescribeProfile$)
     .build() {
 }
 
-class DescribeSecurityPolicyCommand extends client.Command
+class DescribeSecurityPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeSecurityPolicy", {})
     .n("TransferClient", "DescribeSecurityPolicyCommand")
-    .sc(schemas_0.DescribeSecurityPolicy$)
+    .sc(DescribeSecurityPolicy$)
     .build() {
 }
 
-class DescribeServerCommand extends client.Command
+class DescribeServerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeServer", {})
     .n("TransferClient", "DescribeServerCommand")
-    .sc(schemas_0.DescribeServer$)
+    .sc(DescribeServer$)
     .build() {
 }
 
-class DescribeUserCommand extends client.Command
+class DescribeUserCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeUser", {})
     .n("TransferClient", "DescribeUserCommand")
-    .sc(schemas_0.DescribeUser$)
+    .sc(DescribeUser$)
     .build() {
 }
 
-class DescribeWebAppCommand extends client.Command
+class DescribeWebAppCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeWebApp", {})
     .n("TransferClient", "DescribeWebAppCommand")
-    .sc(schemas_0.DescribeWebApp$)
+    .sc(DescribeWebApp$)
     .build() {
 }
 
-class DescribeWebAppCustomizationCommand extends client.Command
+class DescribeWebAppCustomizationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeWebAppCustomization", {})
     .n("TransferClient", "DescribeWebAppCustomizationCommand")
-    .sc(schemas_0.DescribeWebAppCustomization$)
+    .sc(DescribeWebAppCustomization$)
     .build() {
 }
 
-class DescribeWorkflowCommand extends client.Command
+class DescribeWorkflowCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "DescribeWorkflow", {})
     .n("TransferClient", "DescribeWorkflowCommand")
-    .sc(schemas_0.DescribeWorkflow$)
+    .sc(DescribeWorkflow$)
     .build() {
 }
 
-class ImportCertificateCommand extends client.Command
+class ImportCertificateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ImportCertificate", {})
     .n("TransferClient", "ImportCertificateCommand")
-    .sc(schemas_0.ImportCertificate$)
+    .sc(ImportCertificate$)
     .build() {
 }
 
-class ImportHostKeyCommand extends client.Command
+class ImportHostKeyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ImportHostKey", {})
     .n("TransferClient", "ImportHostKeyCommand")
-    .sc(schemas_0.ImportHostKey$)
+    .sc(ImportHostKey$)
     .build() {
 }
 
-class ImportSshPublicKeyCommand extends client.Command
+class ImportSshPublicKeyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ImportSshPublicKey", {})
     .n("TransferClient", "ImportSshPublicKeyCommand")
-    .sc(schemas_0.ImportSshPublicKey$)
+    .sc(ImportSshPublicKey$)
     .build() {
 }
 
-class ListAccessesCommand extends client.Command
+class ListAccessesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListAccesses", {})
     .n("TransferClient", "ListAccessesCommand")
-    .sc(schemas_0.ListAccesses$)
+    .sc(ListAccesses$)
     .build() {
 }
 
-class ListAgreementsCommand extends client.Command
+class ListAgreementsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListAgreements", {})
     .n("TransferClient", "ListAgreementsCommand")
-    .sc(schemas_0.ListAgreements$)
+    .sc(ListAgreements$)
     .build() {
 }
 
-class ListCertificatesCommand extends client.Command
+class ListCertificatesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListCertificates", {})
     .n("TransferClient", "ListCertificatesCommand")
-    .sc(schemas_0.ListCertificates$)
+    .sc(ListCertificates$)
     .build() {
 }
 
-class ListConnectorsCommand extends client.Command
+class ListConnectorsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListConnectors", {})
     .n("TransferClient", "ListConnectorsCommand")
-    .sc(schemas_0.ListConnectors$)
+    .sc(ListConnectors$)
     .build() {
 }
 
-class ListExecutionsCommand extends client.Command
+class ListExecutionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListExecutions", {})
     .n("TransferClient", "ListExecutionsCommand")
-    .sc(schemas_0.ListExecutions$)
+    .sc(ListExecutions$)
     .build() {
 }
 
-class ListFileTransferResultsCommand extends client.Command
+class ListFileTransferResultsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListFileTransferResults", {})
     .n("TransferClient", "ListFileTransferResultsCommand")
-    .sc(schemas_0.ListFileTransferResults$)
+    .sc(ListFileTransferResults$)
     .build() {
 }
 
-class ListHostKeysCommand extends client.Command
+class ListHostKeysCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListHostKeys", {})
     .n("TransferClient", "ListHostKeysCommand")
-    .sc(schemas_0.ListHostKeys$)
+    .sc(ListHostKeys$)
     .build() {
 }
 
-class ListProfilesCommand extends client.Command
+class ListProfilesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListProfiles", {})
     .n("TransferClient", "ListProfilesCommand")
-    .sc(schemas_0.ListProfiles$)
+    .sc(ListProfiles$)
     .build() {
 }
 
-class ListSecurityPoliciesCommand extends client.Command
+class ListSecurityPoliciesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListSecurityPolicies", {})
     .n("TransferClient", "ListSecurityPoliciesCommand")
-    .sc(schemas_0.ListSecurityPolicies$)
+    .sc(ListSecurityPolicies$)
     .build() {
 }
 
-class ListServersCommand extends client.Command
+class ListServersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListServers", {})
     .n("TransferClient", "ListServersCommand")
-    .sc(schemas_0.ListServers$)
+    .sc(ListServers$)
     .build() {
 }
 
-class ListTagsForResourceCommand extends client.Command
+class ListTagsForResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListTagsForResource", {})
     .n("TransferClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class ListUsersCommand extends client.Command
+class ListUsersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListUsers", {})
     .n("TransferClient", "ListUsersCommand")
-    .sc(schemas_0.ListUsers$)
+    .sc(ListUsers$)
     .build() {
 }
 
-class ListWebAppsCommand extends client.Command
+class ListWebAppsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListWebApps", {})
     .n("TransferClient", "ListWebAppsCommand")
-    .sc(schemas_0.ListWebApps$)
+    .sc(ListWebApps$)
     .build() {
 }
 
-class ListWorkflowsCommand extends client.Command
+class ListWorkflowsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "ListWorkflows", {})
     .n("TransferClient", "ListWorkflowsCommand")
-    .sc(schemas_0.ListWorkflows$)
+    .sc(ListWorkflows$)
     .build() {
 }
 
-class SendWorkflowStepStateCommand extends client.Command
+class SendWorkflowStepStateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "SendWorkflowStepState", {})
     .n("TransferClient", "SendWorkflowStepStateCommand")
-    .sc(schemas_0.SendWorkflowStepState$)
+    .sc(SendWorkflowStepState$)
     .build() {
 }
 
-class StartDirectoryListingCommand extends client.Command
+class StartDirectoryListingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "StartDirectoryListing", {})
     .n("TransferClient", "StartDirectoryListingCommand")
-    .sc(schemas_0.StartDirectoryListing$)
+    .sc(StartDirectoryListing$)
     .build() {
 }
 
-class StartFileTransferCommand extends client.Command
+class StartFileTransferCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "StartFileTransfer", {})
     .n("TransferClient", "StartFileTransferCommand")
-    .sc(schemas_0.StartFileTransfer$)
+    .sc(StartFileTransfer$)
     .build() {
 }
 
-class StartRemoteDeleteCommand extends client.Command
+class StartRemoteDeleteCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "StartRemoteDelete", {})
     .n("TransferClient", "StartRemoteDeleteCommand")
-    .sc(schemas_0.StartRemoteDelete$)
+    .sc(StartRemoteDelete$)
     .build() {
 }
 
-class StartRemoteMoveCommand extends client.Command
+class StartRemoteMoveCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "StartRemoteMove", {})
     .n("TransferClient", "StartRemoteMoveCommand")
-    .sc(schemas_0.StartRemoteMove$)
+    .sc(StartRemoteMove$)
     .build() {
 }
 
-class StartServerCommand extends client.Command
+class StartServerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "StartServer", {})
     .n("TransferClient", "StartServerCommand")
-    .sc(schemas_0.StartServer$)
+    .sc(StartServer$)
     .build() {
 }
 
-class StopServerCommand extends client.Command
+class StopServerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "StopServer", {})
     .n("TransferClient", "StopServerCommand")
-    .sc(schemas_0.StopServer$)
+    .sc(StopServer$)
     .build() {
 }
 
-class TagResourceCommand extends client.Command
+class TagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "TagResource", {})
     .n("TransferClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
+    .sc(TagResource$)
     .build() {
 }
 
-class TestConnectionCommand extends client.Command
+class TestConnectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "TestConnection", {})
     .n("TransferClient", "TestConnectionCommand")
-    .sc(schemas_0.TestConnection$)
+    .sc(TestConnection$)
     .build() {
 }
 
-class TestIdentityProviderCommand extends client.Command
+class TestIdentityProviderCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "TestIdentityProvider", {})
     .n("TransferClient", "TestIdentityProviderCommand")
-    .sc(schemas_0.TestIdentityProvider$)
+    .sc(TestIdentityProvider$)
     .build() {
 }
 
-class UntagResourceCommand extends client.Command
+class UntagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "UntagResource", {})
     .n("TransferClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateAccessCommand extends client.Command
+class UpdateAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "UpdateAccess", {})
     .n("TransferClient", "UpdateAccessCommand")
-    .sc(schemas_0.UpdateAccess$)
+    .sc(UpdateAccess$)
     .build() {
 }
 
-class UpdateAgreementCommand extends client.Command
+class UpdateAgreementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "UpdateAgreement", {})
     .n("TransferClient", "UpdateAgreementCommand")
-    .sc(schemas_0.UpdateAgreement$)
+    .sc(UpdateAgreement$)
     .build() {
 }
 
-class UpdateCertificateCommand extends client.Command
+class UpdateCertificateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "UpdateCertificate", {})
     .n("TransferClient", "UpdateCertificateCommand")
-    .sc(schemas_0.UpdateCertificate$)
+    .sc(UpdateCertificate$)
     .build() {
 }
 
-class UpdateConnectorCommand extends client.Command
+class UpdateConnectorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "UpdateConnector", {})
     .n("TransferClient", "UpdateConnectorCommand")
-    .sc(schemas_0.UpdateConnector$)
+    .sc(UpdateConnector$)
     .build() {
 }
 
-class UpdateHostKeyCommand extends client.Command
+class UpdateHostKeyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "UpdateHostKey", {})
     .n("TransferClient", "UpdateHostKeyCommand")
-    .sc(schemas_0.UpdateHostKey$)
+    .sc(UpdateHostKey$)
     .build() {
 }
 
-class UpdateProfileCommand extends client.Command
+class UpdateProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "UpdateProfile", {})
     .n("TransferClient", "UpdateProfileCommand")
-    .sc(schemas_0.UpdateProfile$)
+    .sc(UpdateProfile$)
     .build() {
 }
 
-class UpdateServerCommand extends client.Command
+class UpdateServerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "UpdateServer", {})
     .n("TransferClient", "UpdateServerCommand")
-    .sc(schemas_0.UpdateServer$)
+    .sc(UpdateServer$)
     .build() {
 }
 
-class UpdateUserCommand extends client.Command
+class UpdateUserCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "UpdateUser", {})
     .n("TransferClient", "UpdateUserCommand")
-    .sc(schemas_0.UpdateUser$)
+    .sc(UpdateUser$)
     .build() {
 }
 
-class UpdateWebAppCommand extends client.Command
+class UpdateWebAppCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "UpdateWebApp", {})
     .n("TransferClient", "UpdateWebAppCommand")
-    .sc(schemas_0.UpdateWebApp$)
+    .sc(UpdateWebApp$)
     .build() {
 }
 
-class UpdateWebAppCustomizationCommand extends client.Command
+class UpdateWebAppCustomizationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("TransferService", "UpdateWebAppCustomization", {})
     .n("TransferClient", "UpdateWebAppCustomizationCommand")
-    .sc(schemas_0.UpdateWebAppCustomization$)
+    .sc(UpdateWebAppCustomization$)
     .build() {
 }
 
-const paginateListAccesses = core.createPaginator(TransferClient, ListAccessesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListAccesses = createPaginator(TransferClient, ListAccessesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListAgreements = core.createPaginator(TransferClient, ListAgreementsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListAgreements = createPaginator(TransferClient, ListAgreementsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListCertificates = core.createPaginator(TransferClient, ListCertificatesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListCertificates = createPaginator(TransferClient, ListCertificatesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListConnectors = core.createPaginator(TransferClient, ListConnectorsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListConnectors = createPaginator(TransferClient, ListConnectorsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListExecutions = core.createPaginator(TransferClient, ListExecutionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListExecutions = createPaginator(TransferClient, ListExecutionsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListFileTransferResults = core.createPaginator(TransferClient, ListFileTransferResultsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListFileTransferResults = createPaginator(TransferClient, ListFileTransferResultsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListProfiles = core.createPaginator(TransferClient, ListProfilesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListProfiles = createPaginator(TransferClient, ListProfilesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListSecurityPolicies = core.createPaginator(TransferClient, ListSecurityPoliciesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListSecurityPolicies = createPaginator(TransferClient, ListSecurityPoliciesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListServers = core.createPaginator(TransferClient, ListServersCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListServers = createPaginator(TransferClient, ListServersCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListTagsForResource = core.createPaginator(TransferClient, ListTagsForResourceCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListTagsForResource = createPaginator(TransferClient, ListTagsForResourceCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListUsers = core.createPaginator(TransferClient, ListUsersCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListUsers = createPaginator(TransferClient, ListUsersCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListWebApps = core.createPaginator(TransferClient, ListWebAppsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListWebApps = createPaginator(TransferClient, ListWebAppsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListWorkflows = core.createPaginator(TransferClient, ListWorkflowsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListWorkflows = createPaginator(TransferClient, ListWorkflowsCommand, "NextToken", "NextToken", "MaxResults");
 
-const checkState$1 = async (client$1, input) => {
+const checkState$1 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeServerCommand(input));
+        let result = await client.send(new DescribeServerCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Server.State;
             };
             if (returnComparator() === "OFFLINE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1005,7 +1008,7 @@ const checkState$1 = async (client$1, input) => {
                 return result.Server.State;
             };
             if (returnComparator() === "STOP_FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1013,29 +1016,29 @@ const checkState$1 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForServerOffline = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 3600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilServerOffline = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 3600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return checkExceptions(result);
 };
 
-const checkState = async (client$1, input) => {
+const checkState = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeServerCommand(input));
+        let result = await client.send(new DescribeServerCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Server.State;
             };
             if (returnComparator() === "ONLINE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1044,7 +1047,7 @@ const checkState = async (client$1, input) => {
                 return result.Server.State;
             };
             if (returnComparator() === "START_FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1052,16 +1055,16 @@ const checkState = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForServerOnline = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 3600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilServerOnline = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 3600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
 };
 
 const commands = {
@@ -1158,7 +1161,7 @@ const waiters = {
 };
 class Transfer extends TransferClient {
 }
-client.createAggregatedClient(commands, Transfer, { paginators, waiters });
+createAggregatedClient(commands, Transfer, { paginators, waiters });
 
 const EnforceMessageSigningType = {
     DISABLED: "DISABLED",
@@ -1362,9 +1365,6 @@ const WebAppEndpointType = {
     VPC: "VPC",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.TransferServiceException = TransferServiceException.TransferServiceException;
 exports.AgreementStatusType = AgreementStatusType;
 exports.As2Transport = As2Transport;
 exports.CertificateStatusType = CertificateStatusType;
@@ -1496,23 +1496,3 @@ exports.waitForServerOffline = waitForServerOffline;
 exports.waitForServerOnline = waitForServerOnline;
 exports.waitUntilServerOffline = waitUntilServerOffline;
 exports.waitUntilServerOnline = waitUntilServerOnline;
-Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: schemas_0['__proto__']
-    });
-
-Object.keys(schemas_0).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
-});
-Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: errors['__proto__']
-    });
-
-Object.keys(errors).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
-});