@aws-sdk/client-data-pipeline 3.32.0 → 3.36.0

package/{dist/es → dist-es}/DataPipeline.js

@@ -1,5 +1,4 @@
 import { __extends } from "tslib";
-import { DataPipelineClient } from "./DataPipelineClient";
 import { ActivatePipelineCommand, } from "./commands/ActivatePipelineCommand";
 import { AddTagsCommand } from "./commands/AddTagsCommand";
 import { CreatePipelineCommand, } from "./commands/CreatePipelineCommand";
@@ -19,26 +18,8 @@ import { ReportTaskRunnerHeartbeatCommand, } from "./commands/ReportTaskRunnerHe
 import { SetStatusCommand } from "./commands/SetStatusCommand";
 import { SetTaskStatusCommand, } from "./commands/SetTaskStatusCommand";
 import { ValidatePipelineDefinitionCommand, } from "./commands/ValidatePipelineDefinitionCommand";
-/**
- * <p>AWS Data Pipeline configures and manages a data-driven workflow called a pipeline. AWS Data Pipeline
- *             handles the details of scheduling and ensuring that data dependencies are met so that your application
- *             can focus on processing the data.</p>
- *
- *         <p>AWS Data Pipeline provides a JAR implementation of a task runner called AWS Data Pipeline Task Runner.
- *             AWS Data Pipeline Task Runner provides logic for common data management scenarios, such as performing
- *             database queries and running data analysis using Amazon Elastic MapReduce (Amazon EMR). You can use
- *             AWS Data Pipeline Task Runner as your task runner, or you can write your own task runner to provide
- *             custom data management.</p>
- *
- *         <p>AWS Data Pipeline implements two main sets of functionality. Use the first set to create a pipeline
- *            and define data sources, schedules, dependencies, and the transforms to be performed on the data.
- *            Use the second set in your task runner application to receive the next task ready for processing.
- *            The logic for performing the task, such as querying the data, running data analysis, or converting
- *            the data from one format to another, is contained within the task runner. The task runner performs
- *            the task assigned to it by the web service, reporting progress to the web service as it does so.
- *            When the task is done, the task runner reports the final success or failure of the task to the web service.</p>
- */
-var DataPipeline = /** @class */ (function (_super) {
+import { DataPipelineClient } from "./DataPipelineClient";
+var DataPipeline = (function (_super) {
     __extends(DataPipeline, _super);
     function DataPipeline() {
         return _super !== null && _super.apply(this, arguments) || this;
@@ -312,4 +293,3 @@ var DataPipeline = /** @class */ (function (_super) {
     return DataPipeline;
 }(DataPipelineClient));
 export { DataPipeline };
-//# sourceMappingURL=DataPipeline.js.map

package/dist-es/DataPipelineClient.js

@@ -0,0 +1,37 @@
+import { __extends } from "tslib";
+import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
+import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { Client as __Client, } from "@aws-sdk/smithy-client";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var DataPipelineClient = (function (_super) {
+    __extends(DataPipelineClient, _super);
+    function DataPipelineClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
+    }
+    DataPipelineClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return DataPipelineClient;
+}(__Client));
+export { DataPipelineClient };

package/dist-es/commands/ActivatePipelineCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ActivatePipelineInput, ActivatePipelineOutput } from "../models/models_0";
+import { deserializeAws_json1_1ActivatePipelineCommand, serializeAws_json1_1ActivatePipelineCommand, } from "../protocols/Aws_json1_1";
+var ActivatePipelineCommand = (function (_super) {
+    __extends(ActivatePipelineCommand, _super);
+    function ActivatePipelineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ActivatePipelineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "ActivatePipelineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ActivatePipelineInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ActivatePipelineOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ActivatePipelineCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ActivatePipelineCommand(input, context);
+    };
+    ActivatePipelineCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ActivatePipelineCommand(output, context);
+    };
+    return ActivatePipelineCommand;
+}($Command));
+export { ActivatePipelineCommand };

package/{dist/es → dist-es}/commands/AddTagsCommand.js

@@ -1,40 +1,15 @@
 import { __extends } from "tslib";
-import { AddTagsInput, AddTagsOutput } from "../models/models_0";
-import { deserializeAws_json1_1AddTagsCommand, serializeAws_json1_1AddTagsCommand } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Adds or modifies tags for the specified pipeline.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataPipelineClient, AddTagsCommand } from "@aws-sdk/client-data-pipeline"; // ES Modules import
- * // const { DataPipelineClient, AddTagsCommand } = require("@aws-sdk/client-data-pipeline"); // CommonJS import
- * const client = new DataPipelineClient(config);
- * const command = new AddTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AddTagsCommandInput} for command's `input` shape.
- * @see {@link AddTagsCommandOutput} for command's `response` shape.
- * @see {@link DataPipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var AddTagsCommand = /** @class */ (function (_super) {
+import { AddTagsInput, AddTagsOutput } from "../models/models_0";
+import { deserializeAws_json1_1AddTagsCommand, serializeAws_json1_1AddTagsCommand } from "../protocols/Aws_json1_1";
+var AddTagsCommand = (function (_super) {
     __extends(AddTagsCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function AddTagsCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     AddTagsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -62,4 +37,3 @@ var AddTagsCommand = /** @class */ (function (_super) {
     return AddTagsCommand;
 }($Command));
 export { AddTagsCommand };
-//# sourceMappingURL=AddTagsCommand.js.map

package/dist-es/commands/CreatePipelineCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreatePipelineInput, CreatePipelineOutput } from "../models/models_0";
+import { deserializeAws_json1_1CreatePipelineCommand, serializeAws_json1_1CreatePipelineCommand, } from "../protocols/Aws_json1_1";
+var CreatePipelineCommand = (function (_super) {
+    __extends(CreatePipelineCommand, _super);
+    function CreatePipelineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreatePipelineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "CreatePipelineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreatePipelineInput.filterSensitiveLog,
+            outputFilterSensitiveLog: CreatePipelineOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreatePipelineCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreatePipelineCommand(input, context);
+    };
+    CreatePipelineCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreatePipelineCommand(output, context);
+    };
+    return CreatePipelineCommand;
+}($Command));
+export { CreatePipelineCommand };

package/{dist/es → dist-es}/commands/DeactivatePipelineCommand.js

@@ -1,43 +1,15 @@
 import { __extends } from "tslib";
-import { DeactivatePipelineInput, DeactivatePipelineOutput } from "../models/models_0";
-import { deserializeAws_json1_1DeactivatePipelineCommand, serializeAws_json1_1DeactivatePipelineCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Deactivates the specified running pipeline. The pipeline is set to the <code>DEACTIVATING</code>
- *           state until the deactivation process completes.</p>
- *         <p>To resume a deactivated pipeline, use <a>ActivatePipeline</a>. By default, the pipeline resumes from the last completed execution.
- *           Optionally, you can specify the date and time to resume the pipeline.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DataPipelineClient, DeactivatePipelineCommand } from "@aws-sdk/client-data-pipeline"; // ES Modules import
- * // const { DataPipelineClient, DeactivatePipelineCommand } = require("@aws-sdk/client-data-pipeline"); // CommonJS import
- * const client = new DataPipelineClient(config);
- * const command = new DeactivatePipelineCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeactivatePipelineCommandInput} for command's `input` shape.
- * @see {@link DeactivatePipelineCommandOutput} for command's `response` shape.
- * @see {@link DataPipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var DeactivatePipelineCommand = /** @class */ (function (_super) {
+import { DeactivatePipelineInput, DeactivatePipelineOutput } from "../models/models_0";
+import { deserializeAws_json1_1DeactivatePipelineCommand, serializeAws_json1_1DeactivatePipelineCommand, } from "../protocols/Aws_json1_1";
+var DeactivatePipelineCommand = (function (_super) {
     __extends(DeactivatePipelineCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function DeactivatePipelineCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     DeactivatePipelineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -65,4 +37,3 @@ var DeactivatePipelineCommand = /** @class */ (function (_super) {
     return DeactivatePipelineCommand;
 }($Command));
 export { DeactivatePipelineCommand };
-//# sourceMappingURL=DeactivatePipelineCommand.js.map

package/dist-es/commands/DeletePipelineCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeletePipelineInput } from "../models/models_0";
+import { deserializeAws_json1_1DeletePipelineCommand, serializeAws_json1_1DeletePipelineCommand, } from "../protocols/Aws_json1_1";
+var DeletePipelineCommand = (function (_super) {
+    __extends(DeletePipelineCommand, _super);
+    function DeletePipelineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeletePipelineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "DeletePipelineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeletePipelineInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeletePipelineCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeletePipelineCommand(input, context);
+    };
+    DeletePipelineCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeletePipelineCommand(output, context);
+    };
+    return DeletePipelineCommand;
+}($Command));
+export { DeletePipelineCommand };

package/dist-es/commands/DescribeObjectsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeObjectsInput, DescribeObjectsOutput } from "../models/models_0";
+import { deserializeAws_json1_1DescribeObjectsCommand, serializeAws_json1_1DescribeObjectsCommand, } from "../protocols/Aws_json1_1";
+var DescribeObjectsCommand = (function (_super) {
+    __extends(DescribeObjectsCommand, _super);
+    function DescribeObjectsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeObjectsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "DescribeObjectsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeObjectsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeObjectsOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeObjectsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeObjectsCommand(input, context);
+    };
+    DescribeObjectsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeObjectsCommand(output, context);
+    };
+    return DescribeObjectsCommand;
+}($Command));
+export { DescribeObjectsCommand };

package/dist-es/commands/DescribePipelinesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribePipelinesInput, DescribePipelinesOutput } from "../models/models_0";
+import { deserializeAws_json1_1DescribePipelinesCommand, serializeAws_json1_1DescribePipelinesCommand, } from "../protocols/Aws_json1_1";
+var DescribePipelinesCommand = (function (_super) {
+    __extends(DescribePipelinesCommand, _super);
+    function DescribePipelinesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribePipelinesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "DescribePipelinesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribePipelinesInput.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribePipelinesOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribePipelinesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribePipelinesCommand(input, context);
+    };
+    DescribePipelinesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribePipelinesCommand(output, context);
+    };
+    return DescribePipelinesCommand;
+}($Command));
+export { DescribePipelinesCommand };

package/dist-es/commands/EvaluateExpressionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { EvaluateExpressionInput, EvaluateExpressionOutput } from "../models/models_0";
+import { deserializeAws_json1_1EvaluateExpressionCommand, serializeAws_json1_1EvaluateExpressionCommand, } from "../protocols/Aws_json1_1";
+var EvaluateExpressionCommand = (function (_super) {
+    __extends(EvaluateExpressionCommand, _super);
+    function EvaluateExpressionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    EvaluateExpressionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "EvaluateExpressionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: EvaluateExpressionInput.filterSensitiveLog,
+            outputFilterSensitiveLog: EvaluateExpressionOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    EvaluateExpressionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1EvaluateExpressionCommand(input, context);
+    };
+    EvaluateExpressionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1EvaluateExpressionCommand(output, context);
+    };
+    return EvaluateExpressionCommand;
+}($Command));
+export { EvaluateExpressionCommand };

package/dist-es/commands/GetPipelineDefinitionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetPipelineDefinitionInput, GetPipelineDefinitionOutput } from "../models/models_0";
+import { deserializeAws_json1_1GetPipelineDefinitionCommand, serializeAws_json1_1GetPipelineDefinitionCommand, } from "../protocols/Aws_json1_1";
+var GetPipelineDefinitionCommand = (function (_super) {
+    __extends(GetPipelineDefinitionCommand, _super);
+    function GetPipelineDefinitionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetPipelineDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "GetPipelineDefinitionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetPipelineDefinitionInput.filterSensitiveLog,
+            outputFilterSensitiveLog: GetPipelineDefinitionOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetPipelineDefinitionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetPipelineDefinitionCommand(input, context);
+    };
+    GetPipelineDefinitionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetPipelineDefinitionCommand(output, context);
+    };
+    return GetPipelineDefinitionCommand;
+}($Command));
+export { GetPipelineDefinitionCommand };

package/dist-es/commands/ListPipelinesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListPipelinesInput, ListPipelinesOutput } from "../models/models_0";
+import { deserializeAws_json1_1ListPipelinesCommand, serializeAws_json1_1ListPipelinesCommand, } from "../protocols/Aws_json1_1";
+var ListPipelinesCommand = (function (_super) {
+    __extends(ListPipelinesCommand, _super);
+    function ListPipelinesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListPipelinesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "ListPipelinesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListPipelinesInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListPipelinesOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListPipelinesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListPipelinesCommand(input, context);
+    };
+    ListPipelinesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListPipelinesCommand(output, context);
+    };
+    return ListPipelinesCommand;
+}($Command));
+export { ListPipelinesCommand };

package/dist-es/commands/PollForTaskCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PollForTaskInput, PollForTaskOutput } from "../models/models_0";
+import { deserializeAws_json1_1PollForTaskCommand, serializeAws_json1_1PollForTaskCommand, } from "../protocols/Aws_json1_1";
+var PollForTaskCommand = (function (_super) {
+    __extends(PollForTaskCommand, _super);
+    function PollForTaskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PollForTaskCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "PollForTaskCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PollForTaskInput.filterSensitiveLog,
+            outputFilterSensitiveLog: PollForTaskOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PollForTaskCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1PollForTaskCommand(input, context);
+    };
+    PollForTaskCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1PollForTaskCommand(output, context);
+    };
+    return PollForTaskCommand;
+}($Command));
+export { PollForTaskCommand };

package/dist-es/commands/PutPipelineDefinitionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PutPipelineDefinitionInput, PutPipelineDefinitionOutput } from "../models/models_0";
+import { deserializeAws_json1_1PutPipelineDefinitionCommand, serializeAws_json1_1PutPipelineDefinitionCommand, } from "../protocols/Aws_json1_1";
+var PutPipelineDefinitionCommand = (function (_super) {
+    __extends(PutPipelineDefinitionCommand, _super);
+    function PutPipelineDefinitionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutPipelineDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "PutPipelineDefinitionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutPipelineDefinitionInput.filterSensitiveLog,
+            outputFilterSensitiveLog: PutPipelineDefinitionOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutPipelineDefinitionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1PutPipelineDefinitionCommand(input, context);
+    };
+    PutPipelineDefinitionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1PutPipelineDefinitionCommand(output, context);
+    };
+    return PutPipelineDefinitionCommand;
+}($Command));
+export { PutPipelineDefinitionCommand };

package/dist-es/commands/QueryObjectsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { QueryObjectsInput, QueryObjectsOutput } from "../models/models_0";
+import { deserializeAws_json1_1QueryObjectsCommand, serializeAws_json1_1QueryObjectsCommand, } from "../protocols/Aws_json1_1";
+var QueryObjectsCommand = (function (_super) {
+    __extends(QueryObjectsCommand, _super);
+    function QueryObjectsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    QueryObjectsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "QueryObjectsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: QueryObjectsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: QueryObjectsOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    QueryObjectsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1QueryObjectsCommand(input, context);
+    };
+    QueryObjectsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1QueryObjectsCommand(output, context);
+    };
+    return QueryObjectsCommand;
+}($Command));
+export { QueryObjectsCommand };