@aws-sdk/client-transfer 3.131.0 → 3.142.0

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteCertificateRequest } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
+export interface DeleteCertificateCommandInput extends DeleteCertificateRequest {
+}
+export interface DeleteCertificateCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes the certificate that's specified in the <code>CertificateId</code>
+ *       parameter.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TransferClient, DeleteCertificateCommand } from "@aws-sdk/client-transfer"; // ES Modules import
+ * // const { TransferClient, DeleteCertificateCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
+ * const client = new TransferClient(config);
+ * const command = new DeleteCertificateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @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.
+ *
+ */
+export declare class DeleteCertificateCommand extends $Command<DeleteCertificateCommandInput, DeleteCertificateCommandOutput, TransferClientResolvedConfig> {
+    readonly input: DeleteCertificateCommandInput;
+    constructor(input: DeleteCertificateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCertificateCommandInput, DeleteCertificateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteConnectorRequest } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
+export interface DeleteConnectorCommandInput extends DeleteConnectorRequest {
+}
+export interface DeleteConnectorCommandOutput extends __MetadataBearer {
+}
+/**
+ * <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.
+ * ```javascript
+ * import { TransferClient, DeleteConnectorCommand } from "@aws-sdk/client-transfer"; // ES Modules import
+ * // const { TransferClient, DeleteConnectorCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
+ * const client = new TransferClient(config);
+ * const command = new DeleteConnectorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @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.
+ *
+ */
+export declare class DeleteConnectorCommand extends $Command<DeleteConnectorCommandInput, DeleteConnectorCommandOutput, TransferClientResolvedConfig> {
+    readonly input: DeleteConnectorCommandInput;
+    constructor(input: DeleteConnectorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConnectorCommandInput, DeleteConnectorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteProfileRequest } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
+export interface DeleteProfileCommandInput extends DeleteProfileRequest {
+}
+export interface DeleteProfileCommandOutput extends __MetadataBearer {
+}
+/**
+ * <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.
+ * ```javascript
+ * import { TransferClient, DeleteProfileCommand } from "@aws-sdk/client-transfer"; // ES Modules import
+ * // const { TransferClient, DeleteProfileCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
+ * const client = new TransferClient(config);
+ * const command = new DeleteProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @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.
+ *
+ */
+export declare class DeleteProfileCommand extends $Command<DeleteProfileCommandInput, DeleteProfileCommandOutput, TransferClientResolvedConfig> {
+    readonly input: DeleteProfileCommandInput;
+    constructor(input: DeleteProfileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteProfileCommandInput, DeleteProfileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -9,7 +9,7 @@ export interface DescribeAccessCommandOutput extends DescribeAccessResponse, __M
 /**
  * <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>
+ *       <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>

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeAgreementRequest, DescribeAgreementResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
+export interface DescribeAgreementCommandInput extends DescribeAgreementRequest {
+}
+export interface DescribeAgreementCommandOutput extends DescribeAgreementResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes the agreement that's identified by the <code>AgreementId</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TransferClient, DescribeAgreementCommand } from "@aws-sdk/client-transfer"; // ES Modules import
+ * // const { TransferClient, DescribeAgreementCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
+ * const client = new TransferClient(config);
+ * const command = new DescribeAgreementCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeAgreementCommandInput} for command's `input` shape.
+ * @see {@link DescribeAgreementCommandOutput} for command's `response` shape.
+ * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
+ *
+ */
+export declare class DescribeAgreementCommand extends $Command<DescribeAgreementCommandInput, DescribeAgreementCommandOutput, TransferClientResolvedConfig> {
+    readonly input: DescribeAgreementCommandInput;
+    constructor(input: DescribeAgreementCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAgreementCommandInput, DescribeAgreementCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeCertificateRequest, DescribeCertificateResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
+export interface DescribeCertificateCommandInput extends DescribeCertificateRequest {
+}
+export interface DescribeCertificateCommandOutput extends DescribeCertificateResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes the certificate that's identified by the <code>CertificateId</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TransferClient, DescribeCertificateCommand } from "@aws-sdk/client-transfer"; // ES Modules import
+ * // const { TransferClient, DescribeCertificateCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
+ * const client = new TransferClient(config);
+ * const command = new DescribeCertificateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeCertificateCommandInput} for command's `input` shape.
+ * @see {@link DescribeCertificateCommandOutput} for command's `response` shape.
+ * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
+ *
+ */
+export declare class DescribeCertificateCommand extends $Command<DescribeCertificateCommandInput, DescribeCertificateCommandOutput, TransferClientResolvedConfig> {
+    readonly input: DescribeCertificateCommandInput;
+    constructor(input: DescribeCertificateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCertificateCommandInput, DescribeCertificateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeConnectorRequest, DescribeConnectorResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
+export interface DescribeConnectorCommandInput extends DescribeConnectorRequest {
+}
+export interface DescribeConnectorCommandOutput extends DescribeConnectorResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes the connector that's identified by the <code>ConnectorId.</code>
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TransferClient, DescribeConnectorCommand } from "@aws-sdk/client-transfer"; // ES Modules import
+ * // const { TransferClient, DescribeConnectorCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
+ * const client = new TransferClient(config);
+ * const command = new DescribeConnectorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeConnectorCommandInput} for command's `input` shape.
+ * @see {@link DescribeConnectorCommandOutput} for command's `response` shape.
+ * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
+ *
+ */
+export declare class DescribeConnectorCommand extends $Command<DescribeConnectorCommandInput, DescribeConnectorCommandOutput, TransferClientResolvedConfig> {
+    readonly input: DescribeConnectorCommandInput;
+    constructor(input: DescribeConnectorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConnectorCommandInput, DescribeConnectorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeProfileRequest, DescribeProfileResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
+export interface DescribeProfileCommandInput extends DescribeProfileRequest {
+}
+export interface DescribeProfileCommandOutput extends DescribeProfileResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the details of the profile that's specified by the <code>ProfileId</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TransferClient, DescribeProfileCommand } from "@aws-sdk/client-transfer"; // ES Modules import
+ * // const { TransferClient, DescribeProfileCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
+ * const client = new TransferClient(config);
+ * const command = new DescribeProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeProfileCommandInput} for command's `input` shape.
+ * @see {@link DescribeProfileCommandOutput} for command's `response` shape.
+ * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
+ *
+ */
+export declare class DescribeProfileCommand extends $Command<DescribeProfileCommandInput, DescribeProfileCommandOutput, TransferClientResolvedConfig> {
+    readonly input: DescribeProfileCommandInput;
+    constructor(input: DescribeProfileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeProfileCommandInput, DescribeProfileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ImportCertificateRequest, ImportCertificateResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
+export interface ImportCertificateCommandInput extends ImportCertificateRequest {
+}
+export interface ImportCertificateCommandOutput extends ImportCertificateResponse, __MetadataBearer {
+}
+/**
+ * <p>Imports the signing and encryption certificates that you need to create local (AS2)
+ *       profiles and partner
+ *       profiles.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TransferClient, ImportCertificateCommand } from "@aws-sdk/client-transfer"; // ES Modules import
+ * // const { TransferClient, ImportCertificateCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
+ * const client = new TransferClient(config);
+ * const command = new ImportCertificateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ImportCertificateCommandInput} for command's `input` shape.
+ * @see {@link ImportCertificateCommandOutput} for command's `response` shape.
+ * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
+ *
+ */
+export declare class ImportCertificateCommand extends $Command<ImportCertificateCommandInput, ImportCertificateCommandOutput, TransferClientResolvedConfig> {
+    readonly input: ImportCertificateCommandInput;
+    constructor(input: ImportCertificateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportCertificateCommandInput, ImportCertificateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListConnectorsRequest, ListConnectorsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
+export interface ListConnectorsCommandInput extends ListConnectorsRequest {
+}
+export interface ListConnectorsCommandOutput extends ListConnectorsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the connectors for the specified Region.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TransferClient, ListConnectorsCommand } from "@aws-sdk/client-transfer"; // ES Modules import
+ * // const { TransferClient, ListConnectorsCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
+ * const client = new TransferClient(config);
+ * const command = new ListConnectorsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListConnectorsCommandInput} for command's `input` shape.
+ * @see {@link ListConnectorsCommandOutput} for command's `response` shape.
+ * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
+ *
+ */
+export declare class ListConnectorsCommand extends $Command<ListConnectorsCommandInput, ListConnectorsCommandOutput, TransferClientResolvedConfig> {
+    readonly input: ListConnectorsCommandInput;
+    constructor(input: ListConnectorsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConnectorsCommandInput, ListConnectorsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { StartFileTransferRequest, StartFileTransferResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
+export interface StartFileTransferCommandInput extends StartFileTransferRequest {
+}
+export interface StartFileTransferCommandOutput extends StartFileTransferResponse, __MetadataBearer {
+}
+/**
+ * <p>Begins an outbound file transfer. You specify the <code>ConnectorId</code> and the file
+ *       paths for where to send the files. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TransferClient, StartFileTransferCommand } from "@aws-sdk/client-transfer"; // ES Modules import
+ * // const { TransferClient, StartFileTransferCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
+ * const client = new TransferClient(config);
+ * const command = new StartFileTransferCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartFileTransferCommandInput} for command's `input` shape.
+ * @see {@link StartFileTransferCommandOutput} for command's `response` shape.
+ * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
+ *
+ */
+export declare class StartFileTransferCommand extends $Command<StartFileTransferCommandInput, StartFileTransferCommandOutput, TransferClientResolvedConfig> {
+    readonly input: StartFileTransferCommandInput;
+    constructor(input: StartFileTransferCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartFileTransferCommandInput, StartFileTransferCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -13,7 +13,7 @@ export interface StopServerCommandOutput extends __MetadataBearer {
  *       stopping your server.</p>
  *
  *          <note>
- *             <p>Stopping the server will not reduce or impact your file transfer protocol endpoint
+ *             <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>
  *

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

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

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateCertificateRequest, UpdateCertificateResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
+export interface UpdateCertificateCommandInput extends UpdateCertificateRequest {
+}
+export interface UpdateCertificateCommandOutput extends UpdateCertificateResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates the active and inactive dates for a certificate.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TransferClient, UpdateCertificateCommand } from "@aws-sdk/client-transfer"; // ES Modules import
+ * // const { TransferClient, UpdateCertificateCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
+ * const client = new TransferClient(config);
+ * const command = new UpdateCertificateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateCertificateCommandInput} for command's `input` shape.
+ * @see {@link UpdateCertificateCommandOutput} for command's `response` shape.
+ * @see {@link TransferClientResolvedConfig | config} for TransferClient's `config` shape.
+ *
+ */
+export declare class UpdateCertificateCommand extends $Command<UpdateCertificateCommandInput, UpdateCertificateCommandOutput, TransferClientResolvedConfig> {
+    readonly input: UpdateCertificateCommandInput;
+    constructor(input: UpdateCertificateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCertificateCommandInput, UpdateCertificateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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