@aws-sdk/client-transfer 3.35.0 → 3.38.0

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

@@ -32,339 +32,133 @@ import { UpdateAccessCommandInput, UpdateAccessCommandOutput } from "./commands/
 import { UpdateServerCommandInput, UpdateServerCommandOutput } from "./commands/UpdateServerCommand";
 import { UpdateUserCommandInput, UpdateUserCommandOutput } from "./commands/UpdateUserCommand";
 import { TransferClient } from "./TransferClient";
-/**
- * <p>Amazon Web Services Transfer Family is a fully managed service that enables the transfer of files over the
- *       File Transfer Protocol (FTP), File Transfer Protocol over SSL (FTPS), or Secure Shell (SSH)
- *       File Transfer Protocol (SFTP) directly into and out of Amazon Simple Storage Service (Amazon
- *       S3). Amazon Web Services helps you seamlessly migrate your file transfer workflows to Amazon Web Services Transfer Family by
- *       integrating with existing authentication systems, and providing DNS routing with Amazon Route
- *       53 so nothing changes for your customers and partners, or their applications. With your data
- *       in Amazon S3, you can use it with Amazon Web Services services for processing, analytics, machine learning,
- *       and archiving. Getting started with Amazon Web Services Transfer Family is easy since there is no
- *       infrastructure to buy and set up.</p>
- */
+
 export declare class Transfer extends TransferClient {
-    /**
-     * <p>Used by administrators to choose which groups in the directory should have access to
-     *       upload and download files over the enabled protocols using Amazon Web Services Transfer Family. For example, a
-     *       Microsoft Active Directory might contain 50,000 users, but only a small fraction might need
-     *       the ability to transfer files to the server. An administrator can use
-     *         <code>CreateAccess</code> to limit the access to the correct set of users who need this
-     *       ability.</p>
-     */
+    
     createAccess(args: CreateAccessCommandInput, options?: __HttpHandlerOptions): Promise<CreateAccessCommandOutput>;
     createAccess(args: CreateAccessCommandInput, cb: (err: any, data?: CreateAccessCommandOutput) => void): void;
     createAccess(args: CreateAccessCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateAccessCommandOutput) => void): void;
-    /**
-     * <p>Instantiates an auto-scaling virtual server based on the selected file transfer protocol
-     *       in Amazon Web Services. When you make updates to your file transfer protocol-enabled server or when you work
-     *       with users, use the service-generated <code>ServerId</code> property that is assigned to the
-     *       newly created server.</p>
-     */
+    
     createServer(args: CreateServerCommandInput, options?: __HttpHandlerOptions): Promise<CreateServerCommandOutput>;
     createServer(args: CreateServerCommandInput, cb: (err: any, data?: CreateServerCommandOutput) => void): void;
     createServer(args: CreateServerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateServerCommandOutput) => void): void;
-    /**
-     * <p>Creates a user and associates them with an existing file transfer protocol-enabled server.
-     *       You can only create and associate users with servers that have the
-     *         <code>IdentityProviderType</code> set to <code>SERVICE_MANAGED</code>. Using parameters for
-     *         <code>CreateUser</code>, you can specify the user name, set the home directory, store the
-     *       user's public key, and assign the user's Amazon Web Services Identity and Access Management (IAM)
-     *       role. You can also optionally add a session policy, and assign metadata with tags that can
-     *       be used to group and search for users.</p>
-     */
+    
     createUser(args: CreateUserCommandInput, options?: __HttpHandlerOptions): Promise<CreateUserCommandOutput>;
     createUser(args: CreateUserCommandInput, cb: (err: any, data?: CreateUserCommandOutput) => void): void;
     createUser(args: CreateUserCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateUserCommandOutput) => void): void;
-    /**
-     * <p>
-     *       Allows you to create a workflow with specified steps and step details the workflow invokes after file transfer completes.
-     *       After creating a workflow, you can associate the workflow created with any transfer servers by specifying the <code>workflow-details</code> field in <code>CreateServer</code> and <code>UpdateServer</code> operations.
-     *     </p>
-     */
+    
     createWorkflow(args: CreateWorkflowCommandInput, options?: __HttpHandlerOptions): Promise<CreateWorkflowCommandOutput>;
     createWorkflow(args: CreateWorkflowCommandInput, cb: (err: any, data?: CreateWorkflowCommandOutput) => void): void;
     createWorkflow(args: CreateWorkflowCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateWorkflowCommandOutput) => void): void;
-    /**
-     * <p>Allows you to delete the access specified in the <code>ServerID</code> and
-     *       <code>ExternalID</code> parameters.</p>
-     */
+    
     deleteAccess(args: DeleteAccessCommandInput, options?: __HttpHandlerOptions): Promise<DeleteAccessCommandOutput>;
     deleteAccess(args: DeleteAccessCommandInput, cb: (err: any, data?: DeleteAccessCommandOutput) => void): void;
     deleteAccess(args: DeleteAccessCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteAccessCommandOutput) => void): void;
-    /**
-     * <p>Deletes the file transfer protocol-enabled server that you specify.</p>
-     *
-     *          <p>No response returns from this operation.</p>
-     */
+    
     deleteServer(args: DeleteServerCommandInput, options?: __HttpHandlerOptions): Promise<DeleteServerCommandOutput>;
     deleteServer(args: DeleteServerCommandInput, cb: (err: any, data?: DeleteServerCommandOutput) => void): void;
     deleteServer(args: DeleteServerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteServerCommandOutput) => void): void;
-    /**
-     * <p>Deletes a user's Secure Shell (SSH) public key.</p>
-     */
+    
     deleteSshPublicKey(args: DeleteSshPublicKeyCommandInput, options?: __HttpHandlerOptions): Promise<DeleteSshPublicKeyCommandOutput>;
     deleteSshPublicKey(args: DeleteSshPublicKeyCommandInput, cb: (err: any, data?: DeleteSshPublicKeyCommandOutput) => void): void;
     deleteSshPublicKey(args: DeleteSshPublicKeyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteSshPublicKeyCommandOutput) => void): void;
-    /**
-     * <p>Deletes the user belonging to a file transfer protocol-enabled server you specify.</p>
-     *
-     *          <p>No response returns from this operation.</p>
-     *
-     *          <note>
-     *             <p>When you delete a user from a server, the user's information is lost.</p>
-     *          </note>
-     */
+    
     deleteUser(args: DeleteUserCommandInput, options?: __HttpHandlerOptions): Promise<DeleteUserCommandOutput>;
     deleteUser(args: DeleteUserCommandInput, cb: (err: any, data?: DeleteUserCommandOutput) => void): void;
     deleteUser(args: DeleteUserCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteUserCommandOutput) => void): void;
-    /**
-     * <p>Deletes the specified workflow.</p>
-     */
+    
     deleteWorkflow(args: DeleteWorkflowCommandInput, options?: __HttpHandlerOptions): Promise<DeleteWorkflowCommandOutput>;
     deleteWorkflow(args: DeleteWorkflowCommandInput, cb: (err: any, data?: DeleteWorkflowCommandOutput) => void): void;
     deleteWorkflow(args: DeleteWorkflowCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteWorkflowCommandOutput) => void): void;
-    /**
-     * <p>Describes the access that is assigned to the specific file transfer protocol-enabled
-     *       server, as identified by its <code>ServerId</code> property and its
-     *       <code>ExternalID</code>.</p>
-     *
-     *          <p>The response from this call returns the properties of the access that is associated with
-     *       the <code>ServerId</code> value that was specified.</p>
-     */
+    
     describeAccess(args: DescribeAccessCommandInput, options?: __HttpHandlerOptions): Promise<DescribeAccessCommandOutput>;
     describeAccess(args: DescribeAccessCommandInput, cb: (err: any, data?: DescribeAccessCommandOutput) => void): void;
     describeAccess(args: DescribeAccessCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeAccessCommandOutput) => void): void;
-    /**
-     * <p>You can use <code>DescribeExecution</code> to check the details of the execution of the specified workflow.</p>
-     */
+    
     describeExecution(args: DescribeExecutionCommandInput, options?: __HttpHandlerOptions): Promise<DescribeExecutionCommandOutput>;
     describeExecution(args: DescribeExecutionCommandInput, cb: (err: any, data?: DescribeExecutionCommandOutput) => void): void;
     describeExecution(args: DescribeExecutionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeExecutionCommandOutput) => void): void;
-    /**
-     * <p>Describes the security policy that is attached to your file transfer protocol-enabled
-     *       server. The response contains a description of the security policy's properties. For more
-     *       information about security policies, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/security-policies.html">Working with security
-     *         policies</a>.</p>
-     */
+    
     describeSecurityPolicy(args: DescribeSecurityPolicyCommandInput, options?: __HttpHandlerOptions): Promise<DescribeSecurityPolicyCommandOutput>;
     describeSecurityPolicy(args: DescribeSecurityPolicyCommandInput, cb: (err: any, data?: DescribeSecurityPolicyCommandOutput) => void): void;
     describeSecurityPolicy(args: DescribeSecurityPolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeSecurityPolicyCommandOutput) => void): void;
-    /**
-     * <p>Describes a file transfer protocol-enabled server that you specify by passing the
-     *         <code>ServerId</code> parameter.</p>
-     *
-     *          <p>The response contains a description of a server's properties. When you set
-     *         <code>EndpointType</code> to VPC, the response will contain the
-     *       <code>EndpointDetails</code>.</p>
-     */
+    
     describeServer(args: DescribeServerCommandInput, options?: __HttpHandlerOptions): Promise<DescribeServerCommandOutput>;
     describeServer(args: DescribeServerCommandInput, cb: (err: any, data?: DescribeServerCommandOutput) => void): void;
     describeServer(args: DescribeServerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeServerCommandOutput) => void): void;
-    /**
-     * <p>Describes the user assigned to the specific file transfer protocol-enabled server, as
-     *       identified by its <code>ServerId</code> property.</p>
-     *
-     *          <p>The response from this call returns the properties of the user associated with the
-     *         <code>ServerId</code> value that was specified.</p>
-     */
+    
     describeUser(args: DescribeUserCommandInput, options?: __HttpHandlerOptions): Promise<DescribeUserCommandOutput>;
     describeUser(args: DescribeUserCommandInput, cb: (err: any, data?: DescribeUserCommandOutput) => void): void;
     describeUser(args: DescribeUserCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeUserCommandOutput) => void): void;
-    /**
-     * <p>Describes the specified workflow.</p>
-     */
+    
     describeWorkflow(args: DescribeWorkflowCommandInput, options?: __HttpHandlerOptions): Promise<DescribeWorkflowCommandOutput>;
     describeWorkflow(args: DescribeWorkflowCommandInput, cb: (err: any, data?: DescribeWorkflowCommandOutput) => void): void;
     describeWorkflow(args: DescribeWorkflowCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeWorkflowCommandOutput) => void): void;
-    /**
-     * <p>Adds a Secure Shell (SSH) public key to a user account identified by a
-     *         <code>UserName</code> value assigned to the specific file transfer protocol-enabled server,
-     *       identified by <code>ServerId</code>.</p>
-     *
-     *          <p>The response returns the <code>UserName</code> value, the <code>ServerId</code> value, and
-     *       the name of the <code>SshPublicKeyId</code>.</p>
-     */
+    
     importSshPublicKey(args: ImportSshPublicKeyCommandInput, options?: __HttpHandlerOptions): Promise<ImportSshPublicKeyCommandOutput>;
     importSshPublicKey(args: ImportSshPublicKeyCommandInput, cb: (err: any, data?: ImportSshPublicKeyCommandOutput) => void): void;
     importSshPublicKey(args: ImportSshPublicKeyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ImportSshPublicKeyCommandOutput) => void): void;
-    /**
-     * <p>Lists the details for all the accesses you have on your server.</p>
-     */
+    
     listAccesses(args: ListAccessesCommandInput, options?: __HttpHandlerOptions): Promise<ListAccessesCommandOutput>;
     listAccesses(args: ListAccessesCommandInput, cb: (err: any, data?: ListAccessesCommandOutput) => void): void;
     listAccesses(args: ListAccessesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListAccessesCommandOutput) => void): void;
-    /**
-     * <p>Lists all executions for the specified workflow.</p>
-     */
+    
     listExecutions(args: ListExecutionsCommandInput, options?: __HttpHandlerOptions): Promise<ListExecutionsCommandOutput>;
     listExecutions(args: ListExecutionsCommandInput, cb: (err: any, data?: ListExecutionsCommandOutput) => void): void;
     listExecutions(args: ListExecutionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListExecutionsCommandOutput) => void): void;
-    /**
-     * <p>Lists the security policies that are attached to your file transfer protocol-enabled
-     *       servers.</p>
-     */
+    
     listSecurityPolicies(args: ListSecurityPoliciesCommandInput, options?: __HttpHandlerOptions): Promise<ListSecurityPoliciesCommandOutput>;
     listSecurityPolicies(args: ListSecurityPoliciesCommandInput, cb: (err: any, data?: ListSecurityPoliciesCommandOutput) => void): void;
     listSecurityPolicies(args: ListSecurityPoliciesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListSecurityPoliciesCommandOutput) => void): void;
-    /**
-     * <p>Lists the file transfer protocol-enabled servers that are associated with your Amazon Web Services
-     *       account.</p>
-     */
+    
     listServers(args: ListServersCommandInput, options?: __HttpHandlerOptions): Promise<ListServersCommandOutput>;
     listServers(args: ListServersCommandInput, cb: (err: any, data?: ListServersCommandOutput) => void): void;
     listServers(args: ListServersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListServersCommandOutput) => void): void;
-    /**
-     * <p>Lists all of the tags associated with the Amazon Resource Name (ARN) that you specify. The
-     *       resource can be a user, server, or role.</p>
-     */
+    
     listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
     listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
-    /**
-     * <p>Lists the users for a file transfer protocol-enabled server that you specify by passing
-     *       the <code>ServerId</code> parameter.</p>
-     */
+    
     listUsers(args: ListUsersCommandInput, options?: __HttpHandlerOptions): Promise<ListUsersCommandOutput>;
     listUsers(args: ListUsersCommandInput, cb: (err: any, data?: ListUsersCommandOutput) => void): void;
     listUsers(args: ListUsersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListUsersCommandOutput) => void): void;
-    /**
-     * <p>Lists all of your workflows.</p>
-     */
+    
     listWorkflows(args: ListWorkflowsCommandInput, options?: __HttpHandlerOptions): Promise<ListWorkflowsCommandOutput>;
     listWorkflows(args: ListWorkflowsCommandInput, cb: (err: any, data?: ListWorkflowsCommandOutput) => void): void;
     listWorkflows(args: ListWorkflowsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListWorkflowsCommandOutput) => void): void;
-    /**
-     * <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>
-     */
+    
     sendWorkflowStepState(args: SendWorkflowStepStateCommandInput, options?: __HttpHandlerOptions): Promise<SendWorkflowStepStateCommandOutput>;
     sendWorkflowStepState(args: SendWorkflowStepStateCommandInput, cb: (err: any, data?: SendWorkflowStepStateCommandOutput) => void): void;
     sendWorkflowStepState(args: SendWorkflowStepStateCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SendWorkflowStepStateCommandOutput) => void): void;
-    /**
-     * <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>
-     */
+    
     startServer(args: StartServerCommandInput, options?: __HttpHandlerOptions): Promise<StartServerCommandOutput>;
     startServer(args: StartServerCommandInput, cb: (err: any, data?: StartServerCommandOutput) => void): void;
     startServer(args: StartServerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartServerCommandOutput) => void): void;
-    /**
-     * <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>
-     */
+    
     stopServer(args: StopServerCommandInput, options?: __HttpHandlerOptions): Promise<StopServerCommandOutput>;
     stopServer(args: StopServerCommandInput, cb: (err: any, data?: StopServerCommandOutput) => void): void;
     stopServer(args: StopServerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StopServerCommandOutput) => void): void;
-    /**
-     * <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>
-     */
+    
     tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
     tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
-    /**
-     * <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>
-     */
+    
     testIdentityProvider(args: TestIdentityProviderCommandInput, options?: __HttpHandlerOptions): Promise<TestIdentityProviderCommandOutput>;
     testIdentityProvider(args: TestIdentityProviderCommandInput, cb: (err: any, data?: TestIdentityProviderCommandOutput) => void): void;
     testIdentityProvider(args: TestIdentityProviderCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TestIdentityProviderCommandOutput) => void): void;
-    /**
-     * <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>
-     */
+    
     untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
     untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
-    /**
-     * <p>Allows you to update parameters for the access specified in the <code>ServerID</code> and
-     *       <code>ExternalID</code> parameters.</p>
-     */
+    
     updateAccess(args: UpdateAccessCommandInput, options?: __HttpHandlerOptions): Promise<UpdateAccessCommandOutput>;
     updateAccess(args: UpdateAccessCommandInput, cb: (err: any, data?: UpdateAccessCommandOutput) => void): void;
     updateAccess(args: UpdateAccessCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateAccessCommandOutput) => void): void;
-    /**
-     * <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>
-     */
+    
     updateServer(args: UpdateServerCommandInput, options?: __HttpHandlerOptions): Promise<UpdateServerCommandOutput>;
     updateServer(args: UpdateServerCommandInput, cb: (err: any, data?: UpdateServerCommandOutput) => void): void;
     updateServer(args: UpdateServerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateServerCommandOutput) => void): void;
-    /**
-     * <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>
-     */
+    
     updateUser(args: UpdateUserCommandInput, options?: __HttpHandlerOptions): Promise<UpdateUserCommandOutput>;
     updateUser(args: UpdateUserCommandInput, cb: (err: any, data?: UpdateUserCommandOutput) => void): void;
     updateUser(args: UpdateUserCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateUserCommandOutput) => void): void;

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

@@ -41,132 +41,59 @@ import { UpdateUserCommandInput, UpdateUserCommandOutput } from "./commands/Upda
 export declare type ServiceInputTypes = CreateAccessCommandInput | CreateServerCommandInput | CreateUserCommandInput | CreateWorkflowCommandInput | DeleteAccessCommandInput | DeleteServerCommandInput | DeleteSshPublicKeyCommandInput | DeleteUserCommandInput | DeleteWorkflowCommandInput | DescribeAccessCommandInput | DescribeExecutionCommandInput | DescribeSecurityPolicyCommandInput | DescribeServerCommandInput | DescribeUserCommandInput | DescribeWorkflowCommandInput | ImportSshPublicKeyCommandInput | ListAccessesCommandInput | ListExecutionsCommandInput | ListSecurityPoliciesCommandInput | ListServersCommandInput | ListTagsForResourceCommandInput | ListUsersCommandInput | ListWorkflowsCommandInput | SendWorkflowStepStateCommandInput | StartServerCommandInput | StopServerCommandInput | TagResourceCommandInput | TestIdentityProviderCommandInput | UntagResourceCommandInput | UpdateAccessCommandInput | UpdateServerCommandInput | UpdateUserCommandInput;
 export declare type ServiceOutputTypes = CreateAccessCommandOutput | CreateServerCommandOutput | CreateUserCommandOutput | CreateWorkflowCommandOutput | DeleteAccessCommandOutput | DeleteServerCommandOutput | DeleteSshPublicKeyCommandOutput | DeleteUserCommandOutput | DeleteWorkflowCommandOutput | DescribeAccessCommandOutput | DescribeExecutionCommandOutput | DescribeSecurityPolicyCommandOutput | DescribeServerCommandOutput | DescribeUserCommandOutput | DescribeWorkflowCommandOutput | ImportSshPublicKeyCommandOutput | ListAccessesCommandOutput | ListExecutionsCommandOutput | ListSecurityPoliciesCommandOutput | ListServersCommandOutput | ListTagsForResourceCommandOutput | ListUsersCommandOutput | ListWorkflowsCommandOutput | SendWorkflowStepStateCommandOutput | StartServerCommandOutput | StopServerCommandOutput | TagResourceCommandOutput | TestIdentityProviderCommandOutput | UntagResourceCommandOutput | UpdateAccessCommandOutput | UpdateServerCommandOutput | UpdateUserCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type TransferClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of TransferClient class constructor that set the region, credentials and other options.
- */
+
 export interface TransferClientConfig extends TransferClientConfigType {
 }
 declare type TransferClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of TransferClient class. This is resolved and normalized from the {@link TransferClientConfig | constructor configuration interface}.
- */
+
 export interface TransferClientResolvedConfig extends TransferClientResolvedConfigType {
 }
-/**
- * <p>Amazon Web Services Transfer Family is a fully managed service that enables the transfer of files over the
- *       File Transfer Protocol (FTP), File Transfer Protocol over SSL (FTPS), or Secure Shell (SSH)
- *       File Transfer Protocol (SFTP) directly into and out of Amazon Simple Storage Service (Amazon
- *       S3). Amazon Web Services helps you seamlessly migrate your file transfer workflows to Amazon Web Services Transfer Family by
- *       integrating with existing authentication systems, and providing DNS routing with Amazon Route
- *       53 so nothing changes for your customers and partners, or their applications. With your data
- *       in Amazon S3, you can use it with Amazon Web Services services for processing, analytics, machine learning,
- *       and archiving. Getting started with Amazon Web Services Transfer Family is easy since there is no
- *       infrastructure to buy and set up.</p>
- */
+
 export declare class TransferClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig> {
-    /**
-     * The resolved configuration of TransferClient class. This is resolved and normalized from the {@link TransferClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: TransferClientResolvedConfig;
     constructor(configuration: TransferClientConfig);
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
+    
     destroy(): void;
 }
 export {};

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

@@ -6,34 +6,11 @@ export interface CreateAccessCommandInput extends CreateAccessRequest {
 }
 export interface CreateAccessCommandOutput extends CreateAccessResponse, __MetadataBearer {
 }
-/**
- * <p>Used by administrators to choose which groups in the directory should have access to
- *       upload and download files over the enabled protocols using Amazon Web Services Transfer Family. For example, a
- *       Microsoft Active Directory might contain 50,000 users, but only a small fraction might need
- *       the ability to transfer files to the server. An administrator can use
- *         <code>CreateAccess</code> to limit the access to the correct set of users who need this
- *       ability.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, CreateAccessCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, CreateAccessCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new CreateAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateAccessCommandInput} for command's `input` shape.
- * @see {@link CreateAccessCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateAccessCommand extends $Command<CreateAccessCommandInput, CreateAccessCommandOutput, TransferClientResolvedConfig> {
     readonly input: CreateAccessCommandInput;
     constructor(input: CreateAccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAccessCommandInput, CreateAccessCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateServerCommandInput extends CreateServerRequest {
 }
 export interface CreateServerCommandOutput extends CreateServerResponse, __MetadataBearer {
 }
-/**
- * <p>Instantiates an auto-scaling virtual server based on the selected file transfer protocol
- *       in Amazon Web Services. When you make updates to your file transfer protocol-enabled server or when you work
- *       with users, use the service-generated <code>ServerId</code> property that is assigned to the
- *       newly created server.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, CreateServerCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, CreateServerCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new CreateServerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateServerCommandInput} for command's `input` shape.
- * @see {@link CreateServerCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateServerCommand extends $Command<CreateServerCommandInput, CreateServerCommandOutput, TransferClientResolvedConfig> {
     readonly input: CreateServerCommandInput;
     constructor(input: CreateServerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateServerCommandInput, CreateServerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface CreateUserCommandInput extends CreateUserRequest {
 }
 export interface CreateUserCommandOutput extends CreateUserResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a user and associates them with an existing file transfer protocol-enabled server.
- *       You can only create and associate users with servers that have the
- *         <code>IdentityProviderType</code> set to <code>SERVICE_MANAGED</code>. Using parameters for
- *         <code>CreateUser</code>, you can specify the user name, set the home directory, store the
- *       user's public key, and assign the user's Amazon Web Services Identity and Access Management (IAM)
- *       role. You can also optionally add a session policy, and assign metadata with tags that can
- *       be used to group and search for users.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, CreateUserCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, CreateUserCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new CreateUserCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateUserCommandInput} for command's `input` shape.
- * @see {@link CreateUserCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateUserCommand extends $Command<CreateUserCommandInput, CreateUserCommandOutput, TransferClientResolvedConfig> {
     readonly input: CreateUserCommandInput;
     constructor(input: CreateUserCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateUserCommandInput, CreateUserCommandOutput>;
     private serialize;
     private deserialize;