@aws-sdk/client-datasync 3.34.0 → 3.37.0

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

@@ -1,49 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { CreateAgentRequest, CreateAgentResponse } 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 CreateAgentCommandInput extends CreateAgentRequest {
-}
-export interface CreateAgentCommandOutput extends CreateAgentResponse, __MetadataBearer {
-}
-/**
- * <p>Activates an DataSync agent that you have deployed on your host. The activation
- *       process associates your agent with your account. In the activation process, you specify
- *       information such as the Amazon Web Services Region that you want to activate the agent in. You activate the
- *       agent in the Amazon Web Services Region where your target locations (in Amazon S3 or Amazon EFS) reside. Your
- *       tasks are created in this Amazon Web Services Region.</p>
- *          <p>You can activate the agent in a VPC (virtual private cloud) or provide the agent access to
- *       a VPC endpoint so you can run tasks without going over the public internet.</p>
- *          <p>You can use an agent for more than one location. If a task uses multiple agents, all of
- *       them need to have status AVAILABLE for the task to run. If you use multiple agents for a
- *       source location, the status of all the agents must be AVAILABLE for the task to run. </p>
- *
- *
- *          <p>Agents are automatically updated by Amazon Web Services on a regular basis, using a mechanism that
- *       ensures minimal interruption to your tasks.</p>
- *          <p></p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, CreateAgentCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, CreateAgentCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new CreateAgentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateAgentCommandInput} for command's `input` shape.
- * @see {@link CreateAgentCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateAgentCommand extends $Command<CreateAgentCommandInput, CreateAgentCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: CreateAgentCommandInput;
-    constructor(input: CreateAgentCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAgentCommandInput, CreateAgentCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,36 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { CreateLocationNfsRequest, CreateLocationNfsResponse } 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 CreateLocationNfsCommandInput extends CreateLocationNfsRequest {
-}
-export interface CreateLocationNfsCommandOutput extends CreateLocationNfsResponse, __MetadataBearer {
-}
-/**
- * <p>Defines a file system on a Network File System (NFS) server that can be read from or
- *       written to.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, CreateLocationNfsCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, CreateLocationNfsCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new CreateLocationNfsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLocationNfsCommandInput} for command's `input` shape.
- * @see {@link CreateLocationNfsCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLocationNfsCommand extends $Command<CreateLocationNfsCommandInput, CreateLocationNfsCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: CreateLocationNfsCommandInput;
-    constructor(input: CreateLocationNfsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLocationNfsCommandInput, CreateLocationNfsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,36 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { CreateLocationObjectStorageRequest, CreateLocationObjectStorageResponse } 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 CreateLocationObjectStorageCommandInput extends CreateLocationObjectStorageRequest {
-}
-export interface CreateLocationObjectStorageCommandOutput extends CreateLocationObjectStorageResponse, __MetadataBearer {
-}
-/**
- * <p>Creates an endpoint for a self-managed object storage bucket. For more information
- *       about self-managed object storage locations, see <a href="https://docs.aws.amazon.com/datasync/latest/userguide/create-object-location.html">Creating a location for object storage</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, CreateLocationObjectStorageCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, CreateLocationObjectStorageCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new CreateLocationObjectStorageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLocationObjectStorageCommandInput} for command's `input` shape.
- * @see {@link CreateLocationObjectStorageCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLocationObjectStorageCommand extends $Command<CreateLocationObjectStorageCommandInput, CreateLocationObjectStorageCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: CreateLocationObjectStorageCommandInput;
-    constructor(input: CreateLocationObjectStorageCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLocationObjectStorageCommandInput, CreateLocationObjectStorageCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,41 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { CreateLocationS3Request, CreateLocationS3Response } 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 CreateLocationS3CommandInput extends CreateLocationS3Request {
-}
-export interface CreateLocationS3CommandOutput extends CreateLocationS3Response, __MetadataBearer {
-}
-/**
- * <p>Creates an endpoint for an Amazon S3 bucket.</p>
- *
- *
- *          <p>For
- *       more information, see
- *       <a href="https://docs.aws.amazon.com/datasync/latest/userguide/create-locations-cli.html#create-location-s3-cli">Create an Amazon S3 location</a>
- *       in the <i>DataSync User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, CreateLocationS3Command } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, CreateLocationS3Command } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new CreateLocationS3Command(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLocationS3CommandInput} for command's `input` shape.
- * @see {@link CreateLocationS3CommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLocationS3Command extends $Command<CreateLocationS3CommandInput, CreateLocationS3CommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: CreateLocationS3CommandInput;
-    constructor(input: CreateLocationS3CommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLocationS3CommandInput, CreateLocationS3CommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,36 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { CreateLocationSmbRequest, CreateLocationSmbResponse } 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 CreateLocationSmbCommandInput extends CreateLocationSmbRequest {
-}
-export interface CreateLocationSmbCommandOutput extends CreateLocationSmbResponse, __MetadataBearer {
-}
-/**
- * <p>Defines a file system on a Server Message Block (SMB) server that can be read from or
- *       written to.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, CreateLocationSmbCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, CreateLocationSmbCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new CreateLocationSmbCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLocationSmbCommandInput} for command's `input` shape.
- * @see {@link CreateLocationSmbCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLocationSmbCommand extends $Command<CreateLocationSmbCommandInput, CreateLocationSmbCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: CreateLocationSmbCommandInput;
-    constructor(input: CreateLocationSmbCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLocationSmbCommandInput, CreateLocationSmbCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,53 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { CreateTaskRequest, CreateTaskResponse } 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 CreateTaskCommandInput extends CreateTaskRequest {
-}
-export interface CreateTaskCommandOutput extends CreateTaskResponse, __MetadataBearer {
-}
-/**
- * <p>Creates a task.</p>
- *          <p>A task includes a source location and a destination location, and a configuration
- *       that specifies how data is transferred. A task always transfers data from the source
- *       location to the destination location. The configuration specifies options such as
- *       task scheduling, bandwidth limits, etc. A task is the complete definition of a data
- *       transfer.</p>
- *          <p>When you create a task that transfers data between Amazon Web Services services in different Amazon Web Services Regions,
- *       one of the two locations that you specify must reside in the Region where DataSync is being
- *       used. The other location must be specified in a different Region.</p>
- *          <p>You can transfer data between commercial Amazon Web Services Regions except for China, or between
- *       Amazon Web Services GovCloud (US) Regions.</p>
- *
- *          <important>
- *             <p>When you use DataSync to copy files or objects between Amazon Web Services Regions,
- *       you pay for data transfer between Regions. This is billed as data transfer OUT
- *       from your source Region to your destination Region. For more information,
- *       see <a href="http://aws.amazon.com/ec2/pricing/on-demand/#Data_Transfer">Data Transfer pricing</a>.
- *     </p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, CreateTaskCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, CreateTaskCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new CreateTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTaskCommandInput} for command's `input` shape.
- * @see {@link CreateTaskCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateTaskCommand extends $Command<CreateTaskCommandInput, CreateTaskCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: CreateTaskCommandInput;
-    constructor(input: CreateTaskCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTaskCommandInput, CreateTaskCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,38 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { DeleteAgentRequest, DeleteAgentResponse } 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 DeleteAgentCommandInput extends DeleteAgentRequest {
-}
-export interface DeleteAgentCommandOutput extends DeleteAgentResponse, __MetadataBearer {
-}
-/**
- * <p>Deletes an agent. To specify which agent to delete, use the Amazon Resource Name (ARN)
- *       of the agent in your request. The operation disassociates the agent from your Amazon Web Services account.
- *       However, it doesn't delete the agent virtual machine (VM) from your on-premises
- *       environment.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, DeleteAgentCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, DeleteAgentCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new DeleteAgentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAgentCommandInput} for command's `input` shape.
- * @see {@link DeleteAgentCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteAgentCommand extends $Command<DeleteAgentCommandInput, DeleteAgentCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: DeleteAgentCommandInput;
-    constructor(input: DeleteAgentCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAgentCommandInput, DeleteAgentCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,35 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { DeleteLocationRequest, DeleteLocationResponse } 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 DeleteLocationCommandInput extends DeleteLocationRequest {
-}
-export interface DeleteLocationCommandOutput extends DeleteLocationResponse, __MetadataBearer {
-}
-/**
- * <p>Deletes the configuration of a location used by DataSync. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, DeleteLocationCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, DeleteLocationCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new DeleteLocationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLocationCommandInput} for command's `input` shape.
- * @see {@link DeleteLocationCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteLocationCommand extends $Command<DeleteLocationCommandInput, DeleteLocationCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: DeleteLocationCommandInput;
-    constructor(input: DeleteLocationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLocationCommandInput, DeleteLocationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,35 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { DeleteTaskRequest, DeleteTaskResponse } 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 DeleteTaskCommandInput extends DeleteTaskRequest {
-}
-export interface DeleteTaskCommandOutput extends DeleteTaskResponse, __MetadataBearer {
-}
-/**
- * <p>Deletes a task.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, DeleteTaskCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, DeleteTaskCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new DeleteTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTaskCommandInput} for command's `input` shape.
- * @see {@link DeleteTaskCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteTaskCommand extends $Command<DeleteTaskCommandInput, DeleteTaskCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: DeleteTaskCommandInput;
-    constructor(input: DeleteTaskCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTaskCommandInput, DeleteTaskCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,37 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { DescribeAgentRequest, DescribeAgentResponse } 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 DescribeAgentCommandInput extends DescribeAgentRequest {
-}
-export interface DescribeAgentCommandOutput extends DescribeAgentResponse, __MetadataBearer {
-}
-/**
- * <p>Returns metadata such as the name, the network interfaces, and the status (that is,
- *       whether the agent is running or not) for an agent. To specify which agent to describe, use the
- *       Amazon Resource Name (ARN) of the agent in your request. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, DescribeAgentCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, DescribeAgentCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new DescribeAgentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAgentCommandInput} for command's `input` shape.
- * @see {@link DescribeAgentCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeAgentCommand extends $Command<DescribeAgentCommandInput, DescribeAgentCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: DescribeAgentCommandInput;
-    constructor(input: DescribeAgentCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAgentCommandInput, DescribeAgentCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,36 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { DescribeLocationObjectStorageRequest, DescribeLocationObjectStorageResponse } 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 DescribeLocationObjectStorageCommandInput extends DescribeLocationObjectStorageRequest {
-}
-export interface DescribeLocationObjectStorageCommandOutput extends DescribeLocationObjectStorageResponse, __MetadataBearer {
-}
-/**
- * <p>Returns metadata about a self-managed object storage server location. For more information
- *       about self-managed object storage locations, see <a href="https://docs.aws.amazon.com/datasync/latest/userguide/create-object-location.html">Creating a location for object storage</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, DescribeLocationObjectStorageCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, DescribeLocationObjectStorageCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new DescribeLocationObjectStorageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLocationObjectStorageCommandInput} for command's `input` shape.
- * @see {@link DescribeLocationObjectStorageCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeLocationObjectStorageCommand extends $Command<DescribeLocationObjectStorageCommandInput, DescribeLocationObjectStorageCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: DescribeLocationObjectStorageCommandInput;
-    constructor(input: DescribeLocationObjectStorageCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLocationObjectStorageCommandInput, DescribeLocationObjectStorageCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,42 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { ListAgentsRequest, ListAgentsResponse } 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 ListAgentsCommandInput extends ListAgentsRequest {
-}
-export interface ListAgentsCommandOutput extends ListAgentsResponse, __MetadataBearer {
-}
-/**
- * <p>Returns a list of agents owned by an Amazon Web Services account in the Amazon Web Services Region specified in the
- *       request. The returned list is ordered by agent Amazon Resource Name (ARN).</p>
- *          <p>By default, this operation returns a maximum of 100 agents. This operation supports
- *       pagination that enables you to optionally reduce the number of agents returned in a
- *       response.</p>
- *          <p>If you have more agents than are returned in a response (that is, the response returns
- *       only a truncated list of your agents), the response contains a marker that you can specify in
- *       your next request to fetch the next page of agents.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, ListAgentsCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, ListAgentsCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new ListAgentsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListAgentsCommandInput} for command's `input` shape.
- * @see {@link ListAgentsCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListAgentsCommand extends $Command<ListAgentsCommandInput, ListAgentsCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: ListAgentsCommandInput;
-    constructor(input: ListAgentsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAgentsCommandInput, ListAgentsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,38 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { ListLocationsRequest, ListLocationsResponse } 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 ListLocationsCommandInput extends ListLocationsRequest {
-}
-export interface ListLocationsCommandOutput extends ListLocationsResponse, __MetadataBearer {
-}
-/**
- * <p>Returns a list of source and destination locations.</p>
- *          <p>If you have more locations than are returned in a response (that is, the response
- *       returns only a truncated list of your agents), the response contains a token that you can
- *       specify in your next request to fetch the next page of locations.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, ListLocationsCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, ListLocationsCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new ListLocationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListLocationsCommandInput} for command's `input` shape.
- * @see {@link ListLocationsCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListLocationsCommand extends $Command<ListLocationsCommandInput, ListLocationsCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: ListLocationsCommandInput;
-    constructor(input: ListLocationsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLocationsCommandInput, ListLocationsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,35 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { ListTasksRequest, ListTasksResponse } 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 ListTasksCommandInput extends ListTasksRequest {
-}
-export interface ListTasksCommandOutput extends ListTasksResponse, __MetadataBearer {
-}
-/**
- * <p>Returns a list of all the tasks.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, ListTasksCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, ListTasksCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new ListTasksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTasksCommandInput} for command's `input` shape.
- * @see {@link ListTasksCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListTasksCommand extends $Command<ListTasksCommandInput, ListTasksCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: ListTasksCommandInput;
-    constructor(input: ListTasksCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTasksCommandInput, ListTasksCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,43 +0,0 @@
-import { DataSyncClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DataSyncClient";
-import { StartTaskExecutionRequest, StartTaskExecutionResponse } 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 StartTaskExecutionCommandInput extends StartTaskExecutionRequest {
-}
-export interface StartTaskExecutionCommandOutput extends StartTaskExecutionResponse, __MetadataBearer {
-}
-/**
- * <p>Starts a specific invocation of a task. A <code>TaskExecution</code> value represents
- *       an individual run of a task. Each task can have at most one <code>TaskExecution</code> at a
- *       time.</p>
- *          <p>
- *             <code>TaskExecution</code> has the following transition phases: INITIALIZING |
- *       PREPARING | TRANSFERRING | VERIFYING | SUCCESS/FAILURE. </p>
- *
- *          <p>For detailed information, see the Task Execution section in the Components and
- *       Terminology topic in the <i>DataSync User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataSyncClient, StartTaskExecutionCommand } from "@aws-sdk/client-datasync"; // ES Modules import
- * // const { DataSyncClient, StartTaskExecutionCommand } = require("@aws-sdk/client-datasync"); // CommonJS import
- * const client = new DataSyncClient(config);
- * const command = new StartTaskExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartTaskExecutionCommandInput} for command's `input` shape.
- * @see {@link StartTaskExecutionCommandOutput} for command's `response` shape.
- * @see {@link DataSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartTaskExecutionCommand extends $Command<StartTaskExecutionCommandInput, StartTaskExecutionCommandOutput, DataSyncClientResolvedConfig> {
-    readonly input: StartTaskExecutionCommandInput;
-    constructor(input: StartTaskExecutionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DataSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartTaskExecutionCommandInput, StartTaskExecutionCommandOutput>;
-    private serialize;
-    private deserialize;
-}