@aws-sdk/client-transfer 3.315.0 → 3.316.0

package/dist-types/Transfer.d.ts

@@ -58,572 +58,368 @@ import { UpdateProfileCommandInput, UpdateProfileCommandOutput } from "./command
 import { UpdateServerCommandInput, UpdateServerCommandOutput } from "./commands/UpdateServerCommand";
 import { UpdateUserCommandInput, UpdateUserCommandOutput } from "./commands/UpdateUserCommand";
 import { TransferClient } from "./TransferClient";
-/**
- * @public
- * <p>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) or Amazon EFS.
- *       Additionally, you can use Applicability Statement 2 (AS2) to transfer files into and out of Amazon S3.
- *       Amazon Web Services helps you seamlessly migrate your file transfer workflows to 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 for processing, analytics, machine learning, and
- *       archiving. Getting started with Transfer Family is easy since there is no infrastructure to buy and
- *       set up.</p>
- */
-export declare class Transfer extends TransferClient {
+export interface Transfer {
     /**
-     * @public
-     * <p>Used by administrators to choose which groups in the directory should have access to
-     *       upload and download files over the enabled protocols using 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>
+     * @see {@link CreateAccessCommand}
      */
     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;
     /**
-     * @public
-     * <p>Creates an agreement. An agreement is a bilateral trading partner agreement, or partnership,
-     *       between an Transfer Family server and an AS2 process. The agreement defines the file and message
-     *       transfer relationship between the server and the AS2 process. To define an agreement, Transfer Family
-     *       combines a server, local profile, partner profile, certificate, and other
-     *       attributes.</p>
-     *          <p>The partner is identified with the <code>PartnerProfileId</code>, and the AS2 process is identified with the <code>LocalProfileId</code>.</p>
+     * @see {@link CreateAgreementCommand}
      */
     createAgreement(args: CreateAgreementCommandInput, options?: __HttpHandlerOptions): Promise<CreateAgreementCommandOutput>;
     createAgreement(args: CreateAgreementCommandInput, cb: (err: any, data?: CreateAgreementCommandOutput) => void): void;
     createAgreement(args: CreateAgreementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateAgreementCommandOutput) => void): void;
     /**
-     * @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>
+     * @see {@link CreateConnectorCommand}
      */
     createConnector(args: CreateConnectorCommandInput, options?: __HttpHandlerOptions): Promise<CreateConnectorCommandOutput>;
     createConnector(args: CreateConnectorCommandInput, cb: (err: any, data?: CreateConnectorCommandOutput) => void): void;
     createConnector(args: CreateConnectorCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateConnectorCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates the local or partner profile to use for AS2 transfers.</p>
+     * @see {@link CreateProfileCommand}
      */
     createProfile(args: CreateProfileCommandInput, options?: __HttpHandlerOptions): Promise<CreateProfileCommandOutput>;
     createProfile(args: CreateProfileCommandInput, cb: (err: any, data?: CreateProfileCommandOutput) => void): void;
     createProfile(args: CreateProfileCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateProfileCommandOutput) => void): void;
     /**
-     * @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
-     *       newly created server.</p>
+     * @see {@link CreateServerCommand}
      */
     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;
     /**
-     * @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
-     *         <code>CreateUser</code>, you can specify the user name, set the home directory, store the
-     *       user's public key, and assign the user's 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>
+     * @see {@link CreateUserCommand}
      */
     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;
     /**
-     * @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.
-     *     </p>
+     * @see {@link CreateWorkflowCommand}
      */
     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;
     /**
-     * @public
-     * <p>Allows you to delete the access specified in the <code>ServerID</code> and
-     *       <code>ExternalID</code> parameters.</p>
+     * @see {@link DeleteAccessCommand}
      */
     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;
     /**
-     * @public
-     * <p>Delete the agreement that's specified in the provided <code>AgreementId</code>.</p>
+     * @see {@link DeleteAgreementCommand}
      */
     deleteAgreement(args: DeleteAgreementCommandInput, options?: __HttpHandlerOptions): Promise<DeleteAgreementCommandOutput>;
     deleteAgreement(args: DeleteAgreementCommandInput, cb: (err: any, data?: DeleteAgreementCommandOutput) => void): void;
     deleteAgreement(args: DeleteAgreementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteAgreementCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the certificate that's specified in the <code>CertificateId</code>
-     *       parameter.</p>
+     * @see {@link DeleteCertificateCommand}
      */
     deleteCertificate(args: DeleteCertificateCommandInput, options?: __HttpHandlerOptions): Promise<DeleteCertificateCommandOutput>;
     deleteCertificate(args: DeleteCertificateCommandInput, cb: (err: any, data?: DeleteCertificateCommandOutput) => void): void;
     deleteCertificate(args: DeleteCertificateCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteCertificateCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the agreement that's specified in the provided <code>ConnectorId</code>.</p>
+     * @see {@link DeleteConnectorCommand}
      */
     deleteConnector(args: DeleteConnectorCommandInput, options?: __HttpHandlerOptions): Promise<DeleteConnectorCommandOutput>;
     deleteConnector(args: DeleteConnectorCommandInput, cb: (err: any, data?: DeleteConnectorCommandOutput) => void): void;
     deleteConnector(args: DeleteConnectorCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteConnectorCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the host key that's specified in the <code>HoskKeyId</code> parameter.</p>
+     * @see {@link DeleteHostKeyCommand}
      */
     deleteHostKey(args: DeleteHostKeyCommandInput, options?: __HttpHandlerOptions): Promise<DeleteHostKeyCommandOutput>;
     deleteHostKey(args: DeleteHostKeyCommandInput, cb: (err: any, data?: DeleteHostKeyCommandOutput) => void): void;
     deleteHostKey(args: DeleteHostKeyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteHostKeyCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the profile that's specified in the <code>ProfileId</code> parameter.</p>
+     * @see {@link DeleteProfileCommand}
      */
     deleteProfile(args: DeleteProfileCommandInput, options?: __HttpHandlerOptions): Promise<DeleteProfileCommandOutput>;
     deleteProfile(args: DeleteProfileCommandInput, cb: (err: any, data?: DeleteProfileCommandOutput) => void): void;
     deleteProfile(args: DeleteProfileCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteProfileCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the file transfer protocol-enabled server that you specify.</p>
-     *          <p>No response returns from this operation.</p>
+     * @see {@link DeleteServerCommand}
      */
     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;
     /**
-     * @public
-     * <p>Deletes a user's Secure Shell (SSH) public key.</p>
+     * @see {@link DeleteSshPublicKeyCommand}
      */
     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;
     /**
-     * @public
-     * <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>
+     * @see {@link DeleteUserCommand}
      */
     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;
     /**
-     * @public
-     * <p>Deletes the specified workflow.</p>
+     * @see {@link DeleteWorkflowCommand}
      */
     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;
     /**
-     * @public
-     * <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>
+     * @see {@link DescribeAccessCommand}
      */
     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;
     /**
-     * @public
-     * <p>Describes the agreement that's identified by the <code>AgreementId</code>.</p>
+     * @see {@link DescribeAgreementCommand}
      */
     describeAgreement(args: DescribeAgreementCommandInput, options?: __HttpHandlerOptions): Promise<DescribeAgreementCommandOutput>;
     describeAgreement(args: DescribeAgreementCommandInput, cb: (err: any, data?: DescribeAgreementCommandOutput) => void): void;
     describeAgreement(args: DescribeAgreementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeAgreementCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Describes the certificate that's identified by the <code>CertificateId</code>.</p>
+     * @see {@link DescribeCertificateCommand}
      */
     describeCertificate(args: DescribeCertificateCommandInput, options?: __HttpHandlerOptions): Promise<DescribeCertificateCommandOutput>;
     describeCertificate(args: DescribeCertificateCommandInput, cb: (err: any, data?: DescribeCertificateCommandOutput) => void): void;
     describeCertificate(args: DescribeCertificateCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeCertificateCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Describes the connector that's identified by the <code>ConnectorId.</code>
-     *          </p>
+     * @see {@link DescribeConnectorCommand}
      */
     describeConnector(args: DescribeConnectorCommandInput, options?: __HttpHandlerOptions): Promise<DescribeConnectorCommandOutput>;
     describeConnector(args: DescribeConnectorCommandInput, cb: (err: any, data?: DescribeConnectorCommandOutput) => void): void;
     describeConnector(args: DescribeConnectorCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeConnectorCommandOutput) => void): void;
     /**
-     * @public
-     * <p>You can use <code>DescribeExecution</code> to check the details of the execution of the specified workflow.</p>
+     * @see {@link DescribeExecutionCommand}
      */
     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;
     /**
-     * @public
-     * <p>Returns the details of the host key that's specified by the <code>HostKeyId</code> and <code>ServerId</code>.</p>
+     * @see {@link DescribeHostKeyCommand}
      */
     describeHostKey(args: DescribeHostKeyCommandInput, options?: __HttpHandlerOptions): Promise<DescribeHostKeyCommandOutput>;
     describeHostKey(args: DescribeHostKeyCommandInput, cb: (err: any, data?: DescribeHostKeyCommandOutput) => void): void;
     describeHostKey(args: DescribeHostKeyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeHostKeyCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns the details of the profile that's specified by the <code>ProfileId</code>.</p>
+     * @see {@link DescribeProfileCommand}
      */
     describeProfile(args: DescribeProfileCommandInput, options?: __HttpHandlerOptions): Promise<DescribeProfileCommandOutput>;
     describeProfile(args: DescribeProfileCommandInput, cb: (err: any, data?: DescribeProfileCommandOutput) => void): void;
     describeProfile(args: DescribeProfileCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeProfileCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link DescribeSecurityPolicyCommand}
      */
     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;
     /**
-     * @public
-     * <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>
+     * @see {@link DescribeServerCommand}
      */
     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;
     /**
-     * @public
-     * <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>
+     * @see {@link DescribeUserCommand}
      */
     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;
     /**
-     * @public
-     * <p>Describes the specified workflow.</p>
+     * @see {@link DescribeWorkflowCommand}
      */
     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;
     /**
-     * @public
-     * <p>Imports the signing and encryption certificates that you need to create local (AS2)
-     *       profiles and partner
-     *       profiles.</p>
+     * @see {@link ImportCertificateCommand}
      */
     importCertificate(args: ImportCertificateCommandInput, options?: __HttpHandlerOptions): Promise<ImportCertificateCommandOutput>;
     importCertificate(args: ImportCertificateCommandInput, cb: (err: any, data?: ImportCertificateCommandOutput) => void): void;
     importCertificate(args: ImportCertificateCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ImportCertificateCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Adds a host key to the server that's specified by the <code>ServerId</code>
-     *       parameter.</p>
+     * @see {@link ImportHostKeyCommand}
      */
     importHostKey(args: ImportHostKeyCommandInput, options?: __HttpHandlerOptions): Promise<ImportHostKeyCommandOutput>;
     importHostKey(args: ImportHostKeyCommandInput, cb: (err: any, data?: ImportHostKeyCommandOutput) => void): void;
     importHostKey(args: ImportHostKeyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ImportHostKeyCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link ImportSshPublicKeyCommand}
      */
     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;
     /**
-     * @public
-     * <p>Lists the details for all the accesses you have on your server.</p>
+     * @see {@link ListAccessesCommand}
      */
     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;
     /**
-     * @public
-     * <p>Returns a list of the agreements for the server that's identified by the
-     *         <code>ServerId</code> that you supply. If you want to limit the results to a certain number,
-     *       supply a value for the <code>MaxResults</code> parameter. If you ran the command previously
-     *       and received a value for <code>NextToken</code>, you can supply that value to continue listing
-     *       agreements from where you left off.</p>
+     * @see {@link ListAgreementsCommand}
      */
     listAgreements(args: ListAgreementsCommandInput, options?: __HttpHandlerOptions): Promise<ListAgreementsCommandOutput>;
     listAgreements(args: ListAgreementsCommandInput, cb: (err: any, data?: ListAgreementsCommandOutput) => void): void;
     listAgreements(args: ListAgreementsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListAgreementsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns a list of the current certificates that have been imported into Transfer Family. If you want to
-     *       limit the results to a certain number, supply a value for the <code>MaxResults</code>
-     *       parameter. If you ran the command previously and received a value for the
-     *         <code>NextToken</code> parameter, you can supply that value to continue listing certificates
-     *       from where you left off.</p>
+     * @see {@link ListCertificatesCommand}
      */
     listCertificates(args: ListCertificatesCommandInput, options?: __HttpHandlerOptions): Promise<ListCertificatesCommandOutput>;
     listCertificates(args: ListCertificatesCommandInput, cb: (err: any, data?: ListCertificatesCommandOutput) => void): void;
     listCertificates(args: ListCertificatesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListCertificatesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists the connectors for the specified Region.</p>
+     * @see {@link ListConnectorsCommand}
      */
     listConnectors(args: ListConnectorsCommandInput, options?: __HttpHandlerOptions): Promise<ListConnectorsCommandOutput>;
     listConnectors(args: ListConnectorsCommandInput, cb: (err: any, data?: ListConnectorsCommandOutput) => void): void;
     listConnectors(args: ListConnectorsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListConnectorsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists all executions for the specified workflow.</p>
+     * @see {@link ListExecutionsCommand}
      */
     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;
     /**
-     * @public
-     * <p>Returns a list of host keys for the server that's specified by the <code>ServerId</code>
-     *       parameter.</p>
+     * @see {@link ListHostKeysCommand}
      */
     listHostKeys(args: ListHostKeysCommandInput, options?: __HttpHandlerOptions): Promise<ListHostKeysCommandOutput>;
     listHostKeys(args: ListHostKeysCommandInput, cb: (err: any, data?: ListHostKeysCommandOutput) => void): void;
     listHostKeys(args: ListHostKeysCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListHostKeysCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns a list of the profiles for your system. If you want to limit the results to a
-     *       certain number, supply a value for the <code>MaxResults</code> parameter. If you ran the
-     *       command previously and received a value for <code>NextToken</code>, you can supply that value
-     *       to continue listing profiles from where you left off.</p>
+     * @see {@link ListProfilesCommand}
      */
     listProfiles(args: ListProfilesCommandInput, options?: __HttpHandlerOptions): Promise<ListProfilesCommandOutput>;
     listProfiles(args: ListProfilesCommandInput, cb: (err: any, data?: ListProfilesCommandOutput) => void): void;
     listProfiles(args: ListProfilesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListProfilesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists the security policies that are attached to your file transfer protocol-enabled
-     *       servers.</p>
+     * @see {@link ListSecurityPoliciesCommand}
      */
     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;
     /**
-     * @public
-     * <p>Lists the file transfer protocol-enabled servers that are associated with your Amazon Web Services
-     *       account.</p>
+     * @see {@link ListServersCommand}
      */
     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;
     /**
-     * @public
-     * <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>
+     * @see {@link ListTagsForResourceCommand}
      */
     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;
     /**
-     * @public
-     * <p>Lists the users for a file transfer protocol-enabled server that you specify by passing
-     *       the <code>ServerId</code> parameter.</p>
+     * @see {@link ListUsersCommand}
      */
     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;
     /**
-     * @public
-     * <p>Lists all of your workflows.</p>
+     * @see {@link ListWorkflowsCommand}
      */
     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;
     /**
-     * @public
-     * <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>
+     * @see {@link SendWorkflowStepStateCommand}
      */
     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;
     /**
-     * @public
-     * <p>Begins an outbound file transfer to a remote AS2 server. You specify the <code>ConnectorId</code> and the file
-     *       paths for where to send the files. </p>
+     * @see {@link StartFileTransferCommand}
      */
     startFileTransfer(args: StartFileTransferCommandInput, options?: __HttpHandlerOptions): Promise<StartFileTransferCommandOutput>;
     startFileTransfer(args: StartFileTransferCommandInput, cb: (err: any, data?: StartFileTransferCommandOutput) => void): void;
     startFileTransfer(args: StartFileTransferCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartFileTransferCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link StartServerCommand}
      */
     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;
     /**
-     * @public
-     * <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 does 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>
+     * @see {@link StopServerCommand}
      */
     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;
     /**
-     * @public
-     * <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>
+     * @see {@link TagResourceCommand}
      */
     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;
     /**
-     * @public
-     * <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>
+     * @see {@link TestIdentityProviderCommand}
      */
     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;
     /**
-     * @public
-     * <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>
+     * @see {@link UntagResourceCommand}
      */
     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;
     /**
-     * @public
-     * <p>Allows you to update parameters for the access specified in the <code>ServerID</code> and
-     *       <code>ExternalID</code> parameters.</p>
+     * @see {@link UpdateAccessCommand}
      */
     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;
     /**
-     * @public
-     * <p>Updates some of the parameters for an existing agreement. Provide the
-     *         <code>AgreementId</code> and the <code>ServerId</code> for the agreement that you want to
-     *       update, along with the new values for the parameters to update.</p>
+     * @see {@link UpdateAgreementCommand}
      */
     updateAgreement(args: UpdateAgreementCommandInput, options?: __HttpHandlerOptions): Promise<UpdateAgreementCommandOutput>;
     updateAgreement(args: UpdateAgreementCommandInput, cb: (err: any, data?: UpdateAgreementCommandOutput) => void): void;
     updateAgreement(args: UpdateAgreementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateAgreementCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates the active and inactive dates for a certificate.</p>
+     * @see {@link UpdateCertificateCommand}
      */
     updateCertificate(args: UpdateCertificateCommandInput, options?: __HttpHandlerOptions): Promise<UpdateCertificateCommandOutput>;
     updateCertificate(args: UpdateCertificateCommandInput, cb: (err: any, data?: UpdateCertificateCommandOutput) => void): void;
     updateCertificate(args: UpdateCertificateCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateCertificateCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates some of the parameters for an existing connector. Provide the
-     *         <code>ConnectorId</code> for the connector that you want to update, along with the new
-     *       values for the parameters to update.</p>
+     * @see {@link UpdateConnectorCommand}
      */
     updateConnector(args: UpdateConnectorCommandInput, options?: __HttpHandlerOptions): Promise<UpdateConnectorCommandOutput>;
     updateConnector(args: UpdateConnectorCommandInput, cb: (err: any, data?: UpdateConnectorCommandOutput) => void): void;
     updateConnector(args: UpdateConnectorCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateConnectorCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates the description for the host key that's specified by the <code>ServerId</code> and
-     *         <code>HostKeyId</code> parameters.</p>
+     * @see {@link UpdateHostKeyCommand}
      */
     updateHostKey(args: UpdateHostKeyCommandInput, options?: __HttpHandlerOptions): Promise<UpdateHostKeyCommandOutput>;
     updateHostKey(args: UpdateHostKeyCommandInput, cb: (err: any, data?: UpdateHostKeyCommandOutput) => void): void;
     updateHostKey(args: UpdateHostKeyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateHostKeyCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates some of the parameters for an existing profile. Provide the <code>ProfileId</code>
-     *       for the profile that you want to update, along with the new values for the parameters to
-     *       update.</p>
+     * @see {@link UpdateProfileCommand}
      */
     updateProfile(args: UpdateProfileCommandInput, options?: __HttpHandlerOptions): Promise<UpdateProfileCommandOutput>;
     updateProfile(args: UpdateProfileCommandInput, cb: (err: any, data?: UpdateProfileCommandOutput) => void): void;
     updateProfile(args: UpdateProfileCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateProfileCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link UpdateServerCommand}
      */
     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;
     /**
-     * @public
-     * <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>
+     * @see {@link UpdateUserCommand}
      */
     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;
 }
+/**
+ * @public
+ * <p>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) or Amazon EFS.
+ *       Additionally, you can use Applicability Statement 2 (AS2) to transfer files into and out of Amazon S3.
+ *       Amazon Web Services helps you seamlessly migrate your file transfer workflows to 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 for processing, analytics, machine learning, and
+ *       archiving. Getting started with Transfer Family is easy since there is no infrastructure to buy and
+ *       set up.</p>
+ */
+export declare class Transfer extends TransferClient implements Transfer {
+}