@aws-sdk/client-transfer 3.296.0 → 3.297.0

package/dist-types/commands/CreateConnectorCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateConnectorRequest, CreateConnectorResponse } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link CreateConnectorCommand}.
  */
 export interface CreateConnectorCommandInput extends CreateConnectorRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateConnectorCommand}.
  */
 export interface CreateConnectorCommandOutput extends CreateConnectorResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates the connector, which captures the parameters for an outbound connection for the
  *       AS2 protocol. The connector is required for sending files to an externally hosted AS2 server.
  *       For more details about connectors, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/create-b2b-server.html#configure-as2-connector">Create AS2 connectors</a>.</p>
@@ -27,6 +32,8 @@ export interface CreateConnectorCommandOutput extends CreateConnectorResponse, _
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateConnectorCommandInput - {@link CreateConnectorCommandInput}
+ * @returns {@link CreateConnectorCommandOutput}
  * @see {@link CreateConnectorCommandInput} for command's `input` shape.
  * @see {@link CreateConnectorCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -55,11 +62,20 @@ export interface CreateConnectorCommandOutput extends CreateConnectorResponse, _
 export declare class CreateConnectorCommand extends $Command<CreateConnectorCommandInput, CreateConnectorCommandOutput, TransferClientResolvedConfig> {
     readonly input: CreateConnectorCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateConnectorCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateConnectorCommandInput, CreateConnectorCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateProfileCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateProfileRequest, CreateProfileResponse } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link CreateProfileCommand}.
  */
 export interface CreateProfileCommandInput extends CreateProfileRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateProfileCommand}.
  */
 export interface CreateProfileCommandOutput extends CreateProfileResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates the local or partner profile to use for AS2 transfers.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateProfileCommandOutput extends CreateProfileResponse, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateProfileCommandInput - {@link CreateProfileCommandInput}
+ * @returns {@link CreateProfileCommandOutput}
  * @see {@link CreateProfileCommandInput} for command's `input` shape.
  * @see {@link CreateProfileCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -50,11 +57,20 @@ export interface CreateProfileCommandOutput extends CreateProfileResponse, __Met
 export declare class CreateProfileCommand extends $Command<CreateProfileCommandInput, CreateProfileCommandOutput, TransferClientResolvedConfig> {
     readonly input: CreateProfileCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateProfileCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateProfileCommandInput, CreateProfileCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateServerRequest, CreateServerResponse } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link CreateServerCommand}.
  */
 export interface CreateServerCommandInput extends CreateServerRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateServerCommand}.
  */
 export interface CreateServerCommandOutput extends CreateServerResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -28,6 +33,8 @@ export interface CreateServerCommandOutput extends CreateServerResponse, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateServerCommandInput - {@link CreateServerCommandInput}
+ * @returns {@link CreateServerCommandOutput}
  * @see {@link CreateServerCommandInput} for command's `input` shape.
  * @see {@link CreateServerCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -59,11 +66,20 @@ export interface CreateServerCommandOutput extends CreateServerResponse, __Metad
 export declare class CreateServerCommand extends $Command<CreateServerCommandInput, CreateServerCommandOutput, TransferClientResolvedConfig> {
     readonly input: CreateServerCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateServerCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateServerCommandInput, CreateServerCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateUserRequest, CreateUserResponse } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link CreateUserCommand}.
  */
 export interface CreateUserCommandInput extends CreateUserRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateUserCommand}.
  */
 export interface CreateUserCommandOutput extends CreateUserResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -31,6 +36,8 @@ export interface CreateUserCommandOutput extends CreateUserResponse, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateUserCommandInput - {@link CreateUserCommandInput}
+ * @returns {@link CreateUserCommandOutput}
  * @see {@link CreateUserCommandInput} for command's `input` shape.
  * @see {@link CreateUserCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -56,11 +63,20 @@ export interface CreateUserCommandOutput extends CreateUserResponse, __MetadataB
 export declare class CreateUserCommand extends $Command<CreateUserCommandInput, CreateUserCommandOutput, TransferClientResolvedConfig> {
     readonly input: CreateUserCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateUserCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateUserCommandInput, CreateUserCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateWorkflowRequest, CreateWorkflowResponse } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link CreateWorkflowCommand}.
  */
 export interface CreateWorkflowCommandInput extends CreateWorkflowRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateWorkflowCommand}.
  */
 export interface CreateWorkflowCommandOutput extends CreateWorkflowResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -28,6 +33,8 @@ export interface CreateWorkflowCommandOutput extends CreateWorkflowResponse, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateWorkflowCommandInput - {@link CreateWorkflowCommandInput}
+ * @returns {@link CreateWorkflowCommandOutput}
  * @see {@link CreateWorkflowCommandInput} for command's `input` shape.
  * @see {@link CreateWorkflowCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -55,11 +62,20 @@ export interface CreateWorkflowCommandOutput extends CreateWorkflowResponse, __M
 export declare class CreateWorkflowCommand extends $Command<CreateWorkflowCommandInput, CreateWorkflowCommandOutput, TransferClientResolvedConfig> {
     readonly input: CreateWorkflowCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateWorkflowCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateWorkflowCommandInput, CreateWorkflowCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteAccessRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteAccessCommand}.
  */
 export interface DeleteAccessCommandInput extends DeleteAccessRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteAccessCommand}.
  */
 export interface DeleteAccessCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Allows you to delete the access specified in the <code>ServerID</code> and
  *       <code>ExternalID</code> parameters.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeleteAccessCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteAccessCommandInput - {@link DeleteAccessCommandInput}
+ * @returns {@link DeleteAccessCommandOutput}
  * @see {@link DeleteAccessCommandInput} for command's `input` shape.
  * @see {@link DeleteAccessCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -48,11 +55,20 @@ export interface DeleteAccessCommandOutput extends __MetadataBearer {
 export declare class DeleteAccessCommand extends $Command<DeleteAccessCommandInput, DeleteAccessCommandOutput, TransferClientResolvedConfig> {
     readonly input: DeleteAccessCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteAccessCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAccessCommandInput, DeleteAccessCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteAgreementCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteAgreementRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteAgreementCommand}.
  */
 export interface DeleteAgreementCommandInput extends DeleteAgreementRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteAgreementCommand}.
  */
 export interface DeleteAgreementCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Delete the agreement that's specified in the provided <code>AgreementId</code>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteAgreementCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteAgreementCommandInput - {@link DeleteAgreementCommandInput}
+ * @returns {@link DeleteAgreementCommandOutput}
  * @see {@link DeleteAgreementCommandInput} for command's `input` shape.
  * @see {@link DeleteAgreementCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -47,11 +54,20 @@ export interface DeleteAgreementCommandOutput extends __MetadataBearer {
 export declare class DeleteAgreementCommand extends $Command<DeleteAgreementCommandInput, DeleteAgreementCommandOutput, TransferClientResolvedConfig> {
     readonly input: DeleteAgreementCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteAgreementCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAgreementCommandInput, DeleteAgreementCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteCertificateCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteCertificateRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteCertificateCommand}.
  */
 export interface DeleteCertificateCommandInput extends DeleteCertificateRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteCertificateCommand}.
  */
 export interface DeleteCertificateCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the certificate that's specified in the <code>CertificateId</code>
  *       parameter.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeleteCertificateCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteCertificateCommandInput - {@link DeleteCertificateCommandInput}
+ * @returns {@link DeleteCertificateCommandOutput}
  * @see {@link DeleteCertificateCommandInput} for command's `input` shape.
  * @see {@link DeleteCertificateCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -48,11 +55,20 @@ export interface DeleteCertificateCommandOutput extends __MetadataBearer {
 export declare class DeleteCertificateCommand extends $Command<DeleteCertificateCommandInput, DeleteCertificateCommandOutput, TransferClientResolvedConfig> {
     readonly input: DeleteCertificateCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteCertificateCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCertificateCommandInput, DeleteCertificateCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteConnectorCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteConnectorRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteConnectorCommand}.
  */
 export interface DeleteConnectorCommandInput extends DeleteConnectorRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteConnectorCommand}.
  */
 export interface DeleteConnectorCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the agreement that's specified in the provided <code>ConnectorId</code>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteConnectorCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteConnectorCommandInput - {@link DeleteConnectorCommandInput}
+ * @returns {@link DeleteConnectorCommandOutput}
  * @see {@link DeleteConnectorCommandInput} for command's `input` shape.
  * @see {@link DeleteConnectorCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -47,11 +54,20 @@ export interface DeleteConnectorCommandOutput extends __MetadataBearer {
 export declare class DeleteConnectorCommand extends $Command<DeleteConnectorCommandInput, DeleteConnectorCommandOutput, TransferClientResolvedConfig> {
     readonly input: DeleteConnectorCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteConnectorCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConnectorCommandInput, DeleteConnectorCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteHostKeyCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteHostKeyRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteHostKeyCommand}.
  */
 export interface DeleteHostKeyCommandInput extends DeleteHostKeyRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteHostKeyCommand}.
  */
 export interface DeleteHostKeyCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the host key that's specified in the <code>HoskKeyId</code> parameter.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteHostKeyCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteHostKeyCommandInput - {@link DeleteHostKeyCommandInput}
+ * @returns {@link DeleteHostKeyCommandOutput}
  * @see {@link DeleteHostKeyCommandInput} for command's `input` shape.
  * @see {@link DeleteHostKeyCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -50,11 +57,20 @@ export interface DeleteHostKeyCommandOutput extends __MetadataBearer {
 export declare class DeleteHostKeyCommand extends $Command<DeleteHostKeyCommandInput, DeleteHostKeyCommandOutput, TransferClientResolvedConfig> {
     readonly input: DeleteHostKeyCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteHostKeyCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteHostKeyCommandInput, DeleteHostKeyCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteProfileCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteProfileRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteProfileCommand}.
  */
 export interface DeleteProfileCommandInput extends DeleteProfileRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteProfileCommand}.
  */
 export interface DeleteProfileCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the profile that's specified in the <code>ProfileId</code> parameter.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteProfileCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteProfileCommandInput - {@link DeleteProfileCommandInput}
+ * @returns {@link DeleteProfileCommandOutput}
  * @see {@link DeleteProfileCommandInput} for command's `input` shape.
  * @see {@link DeleteProfileCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -47,11 +54,20 @@ export interface DeleteProfileCommandOutput extends __MetadataBearer {
 export declare class DeleteProfileCommand extends $Command<DeleteProfileCommandInput, DeleteProfileCommandOutput, TransferClientResolvedConfig> {
     readonly input: DeleteProfileCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteProfileCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteProfileCommandInput, DeleteProfileCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteServerRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteServerCommand}.
  */
 export interface DeleteServerCommandInput extends DeleteServerRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteServerCommand}.
  */
 export interface DeleteServerCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the file transfer protocol-enabled server that you specify.</p>
  *          <p>No response returns from this operation.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeleteServerCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteServerCommandInput - {@link DeleteServerCommandInput}
+ * @returns {@link DeleteServerCommandOutput}
  * @see {@link DeleteServerCommandInput} for command's `input` shape.
  * @see {@link DeleteServerCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -51,11 +58,20 @@ export interface DeleteServerCommandOutput extends __MetadataBearer {
 export declare class DeleteServerCommand extends $Command<DeleteServerCommandInput, DeleteServerCommandOutput, TransferClientResolvedConfig> {
     readonly input: DeleteServerCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteServerCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteServerCommandInput, DeleteServerCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteSshPublicKeyRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteSshPublicKeyCommand}.
  */
 export interface DeleteSshPublicKeyCommandInput extends DeleteSshPublicKeyRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteSshPublicKeyCommand}.
  */
 export interface DeleteSshPublicKeyCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface DeleteSshPublicKeyCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteSshPublicKeyCommandInput - {@link DeleteSshPublicKeyCommandInput}
+ * @returns {@link DeleteSshPublicKeyCommandOutput}
  * @see {@link DeleteSshPublicKeyCommandInput} for command's `input` shape.
  * @see {@link DeleteSshPublicKeyCommandOutput} for command's `response` shape.
  * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
@@ -50,11 +57,20 @@ export interface DeleteSshPublicKeyCommandOutput extends __MetadataBearer {
 export declare class DeleteSshPublicKeyCommand extends $Command<DeleteSshPublicKeyCommandInput, DeleteSshPublicKeyCommandOutput, TransferClientResolvedConfig> {
     readonly input: DeleteSshPublicKeyCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteSshPublicKeyCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSshPublicKeyCommandInput, DeleteSshPublicKeyCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }