@aws-sdk/client-transfer 3.35.0 → 3.38.0

package/dist-types/ts3.4/commands/ListUsersCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListUsersCommandInput extends ListUsersRequest {
 }
 export interface ListUsersCommandOutput extends ListUsersResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the users for a file transfer protocol-enabled server that you specify by passing
- *       the <code>ServerId</code> parameter.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, ListUsersCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, ListUsersCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new ListUsersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListUsersCommandInput} for command's `input` shape.
- * @see {@link ListUsersCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListUsersCommand extends $Command<ListUsersCommandInput, ListUsersCommandOutput, TransferClientResolvedConfig> {
     readonly input: ListUsersCommandInput;
     constructor(input: ListUsersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListUsersCommandInput, ListUsersCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListWorkflowsCommand.d.ts

@@ -6,29 +6,11 @@ export interface ListWorkflowsCommandInput extends ListWorkflowsRequest {
 }
 export interface ListWorkflowsCommandOutput extends ListWorkflowsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists all of your workflows.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, ListWorkflowsCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, ListWorkflowsCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new ListWorkflowsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListWorkflowsCommandInput} for command's `input` shape.
- * @see {@link ListWorkflowsCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListWorkflowsCommand extends $Command<ListWorkflowsCommandInput, ListWorkflowsCommandOutput, TransferClientResolvedConfig> {
     readonly input: ListWorkflowsCommandInput;
     constructor(input: ListWorkflowsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListWorkflowsCommandInput, ListWorkflowsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/SendWorkflowStepStateCommand.d.ts

@@ -6,33 +6,11 @@ export interface SendWorkflowStepStateCommandInput extends SendWorkflowStepState
 }
 export interface SendWorkflowStepStateCommandOutput extends SendWorkflowStepStateResponse, __MetadataBearer {
 }
-/**
- * <p>Sends a callback for asynchronous custom steps.</p>
- *          <p>
- *       The <code>ExecutionId</code>, <code>WorkflowId</code>, and <code>Token</code> are passed to the target resource during execution of a custom step of a workflow.
- *       You must include those with their callback as well as providing a status.
- *     </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, SendWorkflowStepStateCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, SendWorkflowStepStateCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new SendWorkflowStepStateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendWorkflowStepStateCommandInput} for command's `input` shape.
- * @see {@link SendWorkflowStepStateCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SendWorkflowStepStateCommand extends $Command<SendWorkflowStepStateCommandInput, SendWorkflowStepStateCommandOutput, TransferClientResolvedConfig> {
     readonly input: SendWorkflowStepStateCommandInput;
     constructor(input: SendWorkflowStepStateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendWorkflowStepStateCommandInput, SendWorkflowStepStateCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StartServerCommand.d.ts

@@ -6,37 +6,11 @@ export interface StartServerCommandInput extends StartServerRequest {
 }
 export interface StartServerCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Changes the state of a file transfer protocol-enabled server from <code>OFFLINE</code> to
- *         <code>ONLINE</code>. It has no impact on a server that is already <code>ONLINE</code>. An
- *         <code>ONLINE</code> server can accept and process file transfer jobs.</p>
- *
- *          <p>The state of <code>STARTING</code> indicates that the server is in an intermediate state,
- *       either not fully able to respond, or not fully online. The values of <code>START_FAILED</code>
- *       can indicate an error condition.</p>
- *
- *          <p>No response is returned from this call.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, StartServerCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, StartServerCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new StartServerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartServerCommandInput} for command's `input` shape.
- * @see {@link StartServerCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartServerCommand extends $Command<StartServerCommandInput, StartServerCommandOutput, TransferClientResolvedConfig> {
     readonly input: StartServerCommandInput;
     constructor(input: StartServerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartServerCommandInput, StartServerCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StopServerCommand.d.ts

@@ -6,43 +6,11 @@ export interface StopServerCommandInput extends StopServerRequest {
 }
 export interface StopServerCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Changes the state of a file transfer protocol-enabled server from <code>ONLINE</code> to
- *         <code>OFFLINE</code>. An <code>OFFLINE</code> server cannot accept and process file transfer
- *       jobs. Information tied to your server, such as server and user properties, are not affected by
- *       stopping your server.</p>
- *
- *          <note>
- *             <p>Stopping the server will not reduce or impact your file transfer protocol endpoint
- *         billing; you must delete the server to stop being billed.</p>
- *          </note>
- *
- *          <p>The state of <code>STOPPING</code> indicates that the server is in an intermediate state,
- *       either not fully able to respond, or not fully offline. The values of <code>STOP_FAILED</code>
- *       can indicate an error condition.</p>
- *
- *          <p>No response is returned from this call.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, StopServerCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, StopServerCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new StopServerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopServerCommandInput} for command's `input` shape.
- * @see {@link StopServerCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopServerCommand extends $Command<StopServerCommandInput, StopServerCommandOutput, TransferClientResolvedConfig> {
     readonly input: StopServerCommandInput;
     constructor(input: StopServerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopServerCommandInput, StopServerCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/TagResourceCommand.d.ts

@@ -6,32 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Attaches a key-value pair to a resource, as identified by its Amazon Resource Name (ARN).
- *       Resources are users, servers, roles, and other entities.</p>
- *
- *          <p>There is no response returned from this call.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, TagResourceCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, TagResourceCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, TransferClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/TestIdentityProviderCommand.d.ts

@@ -6,67 +6,11 @@ export interface TestIdentityProviderCommandInput extends TestIdentityProviderRe
 }
 export interface TestIdentityProviderCommandOutput extends TestIdentityProviderResponse, __MetadataBearer {
 }
-/**
- * <p>If the <code>IdentityProviderType</code> of a file transfer protocol-enabled server is
- *         <code>AWS_DIRECTORY_SERVICE</code> or <code>API_Gateway</code>, tests whether your identity
- *       provider is set up successfully. We highly recommend that you call this operation to test your
- *       authentication method as soon as you create your server. By doing so, you can troubleshoot
- *       issues with the identity provider integration to ensure that your users can successfully use
- *       the service.</p>
- *          <p>
- *       The <code>ServerId</code> and <code>UserName</code> parameters are required. The <code>ServerProtocol</code>, <code>SourceIp</code>, and <code>UserPassword</code> are all optional.
- *     </p>
- *          <note>
- *             <p>
- *         You cannot use <code>TestIdentityProvider</code> if the <code>IdentityProviderType</code> of your server is <code>SERVICE_MANAGED</code>.
- *       </p>
- *          </note>
- *          <ul>
- *             <li>
- *                <p>
- *         If you provide any incorrect values for any parameters, the <code>Response</code> field is empty.
- *       </p>
- *             </li>
- *             <li>
- *                <p>
- *         If you provide a server ID for a server that uses service-managed users, you get an error:
- *       </p>
- *                <p>
- *                   <code>
- *         An error occurred (InvalidRequestException) when calling the TestIdentityProvider operation: s-<i>server-ID</i> not configured for external auth
- *       </code>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *           If you enter a Server ID for the <code>--server-id</code> parameter that does not identify an actual Transfer server, you receive the following error:
- *         </p>
- *                <p>
- *                   <code>An error occurred (ResourceNotFoundException) when calling the TestIdentityProvider operation: Unknown server</code>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, TestIdentityProviderCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, TestIdentityProviderCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new TestIdentityProviderCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TestIdentityProviderCommandInput} for command's `input` shape.
- * @see {@link TestIdentityProviderCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TestIdentityProviderCommand extends $Command<TestIdentityProviderCommandInput, TestIdentityProviderCommandOutput, TransferClientResolvedConfig> {
     readonly input: TestIdentityProviderCommandInput;
     constructor(input: TestIdentityProviderCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestIdentityProviderCommandInput, TestIdentityProviderCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UntagResourceCommand.d.ts

@@ -6,32 +6,11 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {
 }
 export interface UntagResourceCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Detaches a key-value pair from a resource, as identified by its Amazon Resource Name
- *       (ARN). Resources are users, servers, roles, and other entities.</p>
- *
- *          <p>No response is returned from this call.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, UntagResourceCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, UntagResourceCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, TransferClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateAccessCommand.d.ts

@@ -6,30 +6,11 @@ export interface UpdateAccessCommandInput extends UpdateAccessRequest {
 }
 export interface UpdateAccessCommandOutput extends UpdateAccessResponse, __MetadataBearer {
 }
-/**
- * <p>Allows you to update parameters for the access specified in the <code>ServerID</code> and
- *       <code>ExternalID</code> parameters.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, UpdateAccessCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, UpdateAccessCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new UpdateAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAccessCommandInput} for command's `input` shape.
- * @see {@link UpdateAccessCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateAccessCommand extends $Command<UpdateAccessCommandInput, UpdateAccessCommandOutput, TransferClientResolvedConfig> {
     readonly input: UpdateAccessCommandInput;
     constructor(input: UpdateAccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAccessCommandInput, UpdateAccessCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateServerCommand.d.ts

@@ -6,33 +6,11 @@ export interface UpdateServerCommandInput extends UpdateServerRequest {
 }
 export interface UpdateServerCommandOutput extends UpdateServerResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the file transfer protocol-enabled server's properties after that server has
- *       been created.</p>
- *
- *          <p>The <code>UpdateServer</code> call returns the <code>ServerId</code> of the server you
- *       updated.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, UpdateServerCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, UpdateServerCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new UpdateServerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateServerCommandInput} for command's `input` shape.
- * @see {@link UpdateServerCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateServerCommand extends $Command<UpdateServerCommandInput, UpdateServerCommandOutput, TransferClientResolvedConfig> {
     readonly input: UpdateServerCommandInput;
     constructor(input: UpdateServerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateServerCommandInput, UpdateServerCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateUserCommand.d.ts

@@ -6,34 +6,11 @@ export interface UpdateUserCommandInput extends UpdateUserRequest {
 }
 export interface UpdateUserCommandOutput extends UpdateUserResponse, __MetadataBearer {
 }
-/**
- * <p>Assigns new properties to a user. Parameters you pass modify any or all of the following:
- *       the home directory, role, and policy for the <code>UserName</code> and <code>ServerId</code>
- *       you specify.</p>
- *
- *          <p>The response returns the <code>ServerId</code> and the <code>UserName</code> for the
- *       updated user.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, UpdateUserCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, UpdateUserCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new UpdateUserCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateUserCommandInput} for command's `input` shape.
- * @see {@link UpdateUserCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateUserCommand extends $Command<UpdateUserCommandInput, UpdateUserCommandOutput, TransferClientResolvedConfig> {
     readonly input: UpdateUserCommandInput;
     constructor(input: UpdateUserCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateUserCommandInput, UpdateUserCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/index.d.ts

@@ -0,0 +1,32 @@
+export * from "./CreateAccessCommand";
+export * from "./CreateServerCommand";
+export * from "./CreateUserCommand";
+export * from "./CreateWorkflowCommand";
+export * from "./DeleteAccessCommand";
+export * from "./DeleteServerCommand";
+export * from "./DeleteSshPublicKeyCommand";
+export * from "./DeleteUserCommand";
+export * from "./DeleteWorkflowCommand";
+export * from "./DescribeAccessCommand";
+export * from "./DescribeExecutionCommand";
+export * from "./DescribeSecurityPolicyCommand";
+export * from "./DescribeServerCommand";
+export * from "./DescribeUserCommand";
+export * from "./DescribeWorkflowCommand";
+export * from "./ImportSshPublicKeyCommand";
+export * from "./ListAccessesCommand";
+export * from "./ListExecutionsCommand";
+export * from "./ListSecurityPoliciesCommand";
+export * from "./ListServersCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./ListUsersCommand";
+export * from "./ListWorkflowsCommand";
+export * from "./SendWorkflowStepStateCommand";
+export * from "./StartServerCommand";
+export * from "./StopServerCommand";
+export * from "./TagResourceCommand";
+export * from "./TestIdentityProviderCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateAccessCommand";
+export * from "./UpdateServerCommand";
+export * from "./UpdateUserCommand";

package/dist-types/ts3.4/index.d.ts

@@ -1,43 +1,5 @@
-export * from "./TransferClient";
 export * from "./Transfer";
-export * from "./commands/CreateAccessCommand";
-export * from "./commands/CreateServerCommand";
-export * from "./commands/CreateUserCommand";
-export * from "./commands/CreateWorkflowCommand";
-export * from "./commands/DeleteAccessCommand";
-export * from "./commands/DeleteServerCommand";
-export * from "./commands/DeleteSshPublicKeyCommand";
-export * from "./commands/DeleteUserCommand";
-export * from "./commands/DeleteWorkflowCommand";
-export * from "./commands/DescribeAccessCommand";
-export * from "./commands/DescribeExecutionCommand";
-export * from "./commands/DescribeSecurityPolicyCommand";
-export * from "./commands/DescribeServerCommand";
-export * from "./commands/DescribeUserCommand";
-export * from "./commands/DescribeWorkflowCommand";
-export * from "./commands/ImportSshPublicKeyCommand";
-export * from "./commands/ListAccessesCommand";
-export * from "./pagination/ListAccessesPaginator";
-export * from "./commands/ListExecutionsCommand";
-export * from "./pagination/ListExecutionsPaginator";
-export * from "./commands/ListSecurityPoliciesCommand";
-export * from "./pagination/ListSecurityPoliciesPaginator";
-export * from "./commands/ListServersCommand";
-export * from "./pagination/ListServersPaginator";
-export * from "./commands/ListTagsForResourceCommand";
-export * from "./pagination/ListTagsForResourcePaginator";
-export * from "./commands/ListUsersCommand";
-export * from "./pagination/ListUsersPaginator";
-export * from "./commands/ListWorkflowsCommand";
-export * from "./pagination/ListWorkflowsPaginator";
-export * from "./commands/SendWorkflowStepStateCommand";
-export * from "./commands/StartServerCommand";
-export * from "./commands/StopServerCommand";
-export * from "./commands/TagResourceCommand";
-export * from "./commands/TestIdentityProviderCommand";
-export * from "./commands/UntagResourceCommand";
-export * from "./commands/UpdateAccessCommand";
-export * from "./commands/UpdateServerCommand";
-export * from "./commands/UpdateUserCommand";
-export * from "./pagination/Interfaces";
-export * from "./models/index";
+export * from "./TransferClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";