@aws-sdk/client-transfer 3.34.0 → 3.37.0

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

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

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

@@ -1,41 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
-import { DeleteUserRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteUserCommandInput extends DeleteUserRequest {
-}
-export interface DeleteUserCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes the user belonging to a file transfer protocol-enabled server you specify.</p>
- *
- *          <p>No response returns from this operation.</p>
- *
- *          <note>
- *             <p>When you delete a user from a server, the user's information is lost.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, DeleteUserCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, DeleteUserCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new DeleteUserCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteUserCommandInput} for command's `input` shape.
- * @see {@link DeleteUserCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteUserCommand extends $Command<DeleteUserCommandInput, DeleteUserCommandOutput, TransferClientResolvedConfig> {
-    readonly input: DeleteUserCommandInput;
-    constructor(input: DeleteUserCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteUserCommandInput, DeleteUserCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

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

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

@@ -1,40 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
-import { DescribeAccessRequest, DescribeAccessResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeAccessCommandInput extends DescribeAccessRequest {
-}
-export interface DescribeAccessCommandOutput extends DescribeAccessResponse, __MetadataBearer {
-}
-/**
- * <p>Describes the access that is assigned to the specific file transfer protocol-enabled
- *       server, as identified by its <code>ServerId</code> property and its
- *       <code>ExternalID</code>.</p>
- *
- *          <p>The response from this call returns the properties of the access that is associated with
- *       the <code>ServerId</code> value that was specified.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, DescribeAccessCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, DescribeAccessCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new DescribeAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAccessCommandInput} for command's `input` shape.
- * @see {@link DescribeAccessCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeAccessCommand extends $Command<DescribeAccessCommandInput, DescribeAccessCommandOutput, TransferClientResolvedConfig> {
-    readonly input: DescribeAccessCommandInput;
-    constructor(input: DescribeAccessCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAccessCommandInput, DescribeAccessCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

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

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

@@ -1,38 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
-import { DescribeSecurityPolicyRequest, DescribeSecurityPolicyResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeSecurityPolicyCommandInput extends DescribeSecurityPolicyRequest {
-}
-export interface DescribeSecurityPolicyCommandOutput extends DescribeSecurityPolicyResponse, __MetadataBearer {
-}
-/**
- * <p>Describes the security policy that is attached to your file transfer protocol-enabled
- *       server. The response contains a description of the security policy's properties. For more
- *       information about security policies, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/security-policies.html">Working with security
- *         policies</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, DescribeSecurityPolicyCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, DescribeSecurityPolicyCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new DescribeSecurityPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSecurityPolicyCommandInput} for command's `input` shape.
- * @see {@link DescribeSecurityPolicyCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeSecurityPolicyCommand extends $Command<DescribeSecurityPolicyCommandInput, DescribeSecurityPolicyCommandOutput, TransferClientResolvedConfig> {
-    readonly input: DescribeSecurityPolicyCommandInput;
-    constructor(input: DescribeSecurityPolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSecurityPolicyCommandInput, DescribeSecurityPolicyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,40 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
-import { DescribeServerRequest, DescribeServerResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeServerCommandInput extends DescribeServerRequest {
-}
-export interface DescribeServerCommandOutput extends DescribeServerResponse, __MetadataBearer {
-}
-/**
- * <p>Describes a file transfer protocol-enabled server that you specify by passing the
- *         <code>ServerId</code> parameter.</p>
- *
- *          <p>The response contains a description of a server's properties. When you set
- *         <code>EndpointType</code> to VPC, the response will contain the
- *       <code>EndpointDetails</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, DescribeServerCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, DescribeServerCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new DescribeServerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeServerCommandInput} for command's `input` shape.
- * @see {@link DescribeServerCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeServerCommand extends $Command<DescribeServerCommandInput, DescribeServerCommandOutput, TransferClientResolvedConfig> {
-    readonly input: DescribeServerCommandInput;
-    constructor(input: DescribeServerCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeServerCommandInput, DescribeServerCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,39 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
-import { DescribeUserRequest, DescribeUserResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeUserCommandInput extends DescribeUserRequest {
-}
-export interface DescribeUserCommandOutput extends DescribeUserResponse, __MetadataBearer {
-}
-/**
- * <p>Describes the user assigned to the specific file transfer protocol-enabled server, as
- *       identified by its <code>ServerId</code> property.</p>
- *
- *          <p>The response from this call returns the properties of the user associated with the
- *         <code>ServerId</code> value that was specified.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, DescribeUserCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, DescribeUserCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new DescribeUserCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeUserCommandInput} for command's `input` shape.
- * @see {@link DescribeUserCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeUserCommand extends $Command<DescribeUserCommandInput, DescribeUserCommandOutput, TransferClientResolvedConfig> {
-    readonly input: DescribeUserCommandInput;
-    constructor(input: DescribeUserCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeUserCommandInput, DescribeUserCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,40 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
-import { ImportSshPublicKeyRequest, ImportSshPublicKeyResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ImportSshPublicKeyCommandInput extends ImportSshPublicKeyRequest {
-}
-export interface ImportSshPublicKeyCommandOutput extends ImportSshPublicKeyResponse, __MetadataBearer {
-}
-/**
- * <p>Adds a Secure Shell (SSH) public key to a user account identified by a
- *         <code>UserName</code> value assigned to the specific file transfer protocol-enabled server,
- *       identified by <code>ServerId</code>.</p>
- *
- *          <p>The response returns the <code>UserName</code> value, the <code>ServerId</code> value, and
- *       the name of the <code>SshPublicKeyId</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, ImportSshPublicKeyCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, ImportSshPublicKeyCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new ImportSshPublicKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportSshPublicKeyCommandInput} for command's `input` shape.
- * @see {@link ImportSshPublicKeyCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ImportSshPublicKeyCommand extends $Command<ImportSshPublicKeyCommandInput, ImportSshPublicKeyCommandOutput, TransferClientResolvedConfig> {
-    readonly input: ImportSshPublicKeyCommandInput;
-    constructor(input: ImportSshPublicKeyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportSshPublicKeyCommandInput, ImportSshPublicKeyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

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

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

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

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

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

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

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

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

@@ -1,36 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TransferClientResolvedConfig } from "../TransferClient";
-import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
-}
-export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
-}
-/**
- * <p>Lists all of the tags associated with the Amazon Resource Name (ARN) that you specify. The
- *       resource can be a user, server, or role.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TransferClient, ListTagsForResourceCommand } from "@aws-sdk/client-transfer"; // ES Modules import
- * // const { TransferClient, ListTagsForResourceCommand } = require("@aws-sdk/client-transfer"); // CommonJS import
- * const client = new TransferClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link TransferClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, TransferClientResolvedConfig> {
-    readonly input: ListTagsForResourceCommandInput;
-    constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TransferClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListUsersCommand.d.ts

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

package/dist/types/ts3.4/commands/SendWorkflowStepStateCommand.d.ts

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