@aws-sdk/client-transfer 3.35.0 → 3.38.0

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

@@ -6,32 +6,11 @@ export interface CreateWorkflowCommandInput extends CreateWorkflowRequest {
 }
 export interface CreateWorkflowCommandOutput extends CreateWorkflowResponse, __MetadataBearer {
 }
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, CreateWorkflowCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, CreateWorkflowCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new CreateWorkflowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateWorkflowCommandInput} for command's `input` shape.
- * @see {@link CreateWorkflowCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateWorkflowCommand extends $Command<CreateWorkflowCommandInput, CreateWorkflowCommandOutput, TransferClientResolvedConfig> {
     readonly input: CreateWorkflowCommandInput;
     constructor(input: CreateWorkflowCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateWorkflowCommandInput, CreateWorkflowCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteAccessCommandInput extends DeleteAccessRequest {
 }
 export interface DeleteAccessCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Allows you to delete 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, DeleteAccessCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, DeleteAccessCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new DeleteAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAccessCommandInput} for command's `input` shape.
- * @see {@link DeleteAccessCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteAccessCommand extends $Command<DeleteAccessCommandInput, DeleteAccessCommandOutput, TransferClientResolvedConfig> {
     readonly input: DeleteAccessCommandInput;
     constructor(input: DeleteAccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAccessCommandInput, DeleteAccessCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,34 +6,11 @@ export interface DescribeAccessCommandInput extends DescribeAccessRequest {
 }
 export interface DescribeAccessCommandOutput extends DescribeAccessResponse, __MetadataBearer {
 }
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, DescribeAccessCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, DescribeAccessCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new DescribeAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAccessCommandInput} for command's `input` shape.
- * @see {@link DescribeAccessCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAccessCommand extends $Command<DescribeAccessCommandInput, DescribeAccessCommandOutput, TransferClientResolvedConfig> {
     readonly input: DescribeAccessCommandInput;
     constructor(input: DescribeAccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAccessCommandInput, DescribeAccessCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeExecutionCommandInput extends DescribeExecutionRequest
 }
 export interface DescribeExecutionCommandOutput extends DescribeExecutionResponse, __MetadataBearer {
 }
-/**
- * <p>You can use <code>DescribeExecution</code> to check the details of the execution of the specified workflow.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, DescribeExecutionCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, DescribeExecutionCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new DescribeExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeExecutionCommandInput} for command's `input` shape.
- * @see {@link DescribeExecutionCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeExecutionCommand extends $Command<DescribeExecutionCommandInput, DescribeExecutionCommandOutput, TransferClientResolvedConfig> {
     readonly input: DescribeExecutionCommandInput;
     constructor(input: DescribeExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeExecutionCommandInput, DescribeExecutionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeSecurityPolicyCommandInput extends DescribeSecurityPoli
 }
 export interface DescribeSecurityPolicyCommandOutput extends DescribeSecurityPolicyResponse, __MetadataBearer {
 }
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, DescribeSecurityPolicyCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, DescribeSecurityPolicyCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new DescribeSecurityPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSecurityPolicyCommandInput} for command's `input` shape.
- * @see {@link DescribeSecurityPolicyCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSecurityPolicyCommand extends $Command<DescribeSecurityPolicyCommandInput, DescribeSecurityPolicyCommandOutput, TransferClientResolvedConfig> {
     readonly input: DescribeSecurityPolicyCommandInput;
     constructor(input: DescribeSecurityPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSecurityPolicyCommandInput, DescribeSecurityPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DescribeServerCommandInput extends DescribeServerRequest {
 }
 export interface DescribeServerCommandOutput extends DescribeServerResponse, __MetadataBearer {
 }
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, DescribeServerCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, DescribeServerCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new DescribeServerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeServerCommandInput} for command's `input` shape.
- * @see {@link DescribeServerCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeServerCommand extends $Command<DescribeServerCommandInput, DescribeServerCommandOutput, TransferClientResolvedConfig> {
     readonly input: DescribeServerCommandInput;
     constructor(input: DescribeServerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeServerCommandInput, DescribeServerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribeUserCommandInput extends DescribeUserRequest {
 }
 export interface DescribeUserCommandOutput extends DescribeUserResponse, __MetadataBearer {
 }
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, DescribeUserCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, DescribeUserCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new DescribeUserCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeUserCommandInput} for command's `input` shape.
- * @see {@link DescribeUserCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeUserCommand extends $Command<DescribeUserCommandInput, DescribeUserCommandOutput, TransferClientResolvedConfig> {
     readonly input: DescribeUserCommandInput;
     constructor(input: DescribeUserCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeUserCommandInput, DescribeUserCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,34 +6,11 @@ export interface ImportSshPublicKeyCommandInput extends ImportSshPublicKeyReques
 }
 export interface ImportSshPublicKeyCommandOutput extends ImportSshPublicKeyResponse, __MetadataBearer {
 }
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, ImportSshPublicKeyCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, ImportSshPublicKeyCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new ImportSshPublicKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportSshPublicKeyCommandInput} for command's `input` shape.
- * @see {@link ImportSshPublicKeyCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportSshPublicKeyCommand extends $Command<ImportSshPublicKeyCommandInput, ImportSshPublicKeyCommandOutput, TransferClientResolvedConfig> {
     readonly input: ImportSshPublicKeyCommandInput;
     constructor(input: ImportSshPublicKeyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportSshPublicKeyCommandInput, ImportSshPublicKeyCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface ListSecurityPoliciesCommandInput extends ListSecurityPoliciesRe
 }
 export interface ListSecurityPoliciesCommandOutput extends ListSecurityPoliciesResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the security policies that are attached to your file transfer protocol-enabled
- *       servers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, ListSecurityPoliciesCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, ListSecurityPoliciesCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new ListSecurityPoliciesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListSecurityPoliciesCommandInput} for command's `input` shape.
- * @see {@link ListSecurityPoliciesCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListSecurityPoliciesCommand extends $Command<ListSecurityPoliciesCommandInput, ListSecurityPoliciesCommandOutput, TransferClientResolvedConfig> {
     readonly input: ListSecurityPoliciesCommandInput;
     constructor(input: ListSecurityPoliciesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSecurityPoliciesCommandInput, ListSecurityPoliciesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListServersCommandInput extends ListServersRequest {
 }
 export interface ListServersCommandOutput extends ListServersResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the file transfer protocol-enabled servers that are associated with your Amazon Web Services
- *       account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, ListServersCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, ListServersCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new ListServersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListServersCommandInput} for command's `input` shape.
- * @see {@link ListServersCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListServersCommand extends $Command<ListServersCommandInput, ListServersCommandOutput, TransferClientResolvedConfig> {
     readonly input: ListServersCommandInput;
     constructor(input: ListServersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListServersCommandInput, ListServersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, ListTagsForResourceCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, ListTagsForResourceCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, TransferClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;