@aws-sdk/client-data-pipeline 3.183.0 → 3.186.0

package/dist-es/commands/DeactivatePipelineCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeactivatePipelineInputFilterSensitiveLog, DeactivatePipelineOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeactivatePipelineCommand, serializeAws_json1_1DeactivatePipelineCommand, } from "../protocols/Aws_json1_1";
-export class DeactivatePipelineCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeactivatePipelineCommand = (function (_super) {
+    __extends(DeactivatePipelineCommand, _super);
+    function DeactivatePipelineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeactivatePipelineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataPipelineClient";
-        const commandName = "DeactivatePipelineCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DataPipelineClient";
+        var commandName = "DeactivatePipelineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeactivatePipelineInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeactivatePipelineOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeactivatePipelineCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeactivatePipelineCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeactivatePipelineCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeactivatePipelineCommand(output, context);
-    }
-}
+    };
+    return DeactivatePipelineCommand;
+}($Command));
+export { DeactivatePipelineCommand };

package/dist-es/commands/DeletePipelineCommand.js

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

package/dist-es/commands/DescribeObjectsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeObjectsInputFilterSensitiveLog, DescribeObjectsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeObjectsCommand, serializeAws_json1_1DescribeObjectsCommand, } from "../protocols/Aws_json1_1";
-export class DescribeObjectsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeObjectsCommand = (function (_super) {
+    __extends(DescribeObjectsCommand, _super);
+    function DescribeObjectsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeObjectsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataPipelineClient";
-        const commandName = "DescribeObjectsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DescribeObjectsInputFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeObjectsOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DescribeObjectsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeObjectsCommand(output, context);
-    }
-}
+    };
+    return DescribeObjectsCommand;
+}($Command));
+export { DescribeObjectsCommand };

package/dist-es/commands/DescribePipelinesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribePipelinesInputFilterSensitiveLog, DescribePipelinesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribePipelinesCommand, serializeAws_json1_1DescribePipelinesCommand, } from "../protocols/Aws_json1_1";
-export class DescribePipelinesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribePipelinesCommand = (function (_super) {
+    __extends(DescribePipelinesCommand, _super);
+    function DescribePipelinesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribePipelinesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataPipelineClient";
-        const commandName = "DescribePipelinesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DescribePipelinesInputFilterSensitiveLog,
             outputFilterSensitiveLog: DescribePipelinesOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DescribePipelinesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribePipelinesCommand(output, context);
-    }
-}
+    };
+    return DescribePipelinesCommand;
+}($Command));
+export { DescribePipelinesCommand };

package/dist-es/commands/EvaluateExpressionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { EvaluateExpressionInputFilterSensitiveLog, EvaluateExpressionOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1EvaluateExpressionCommand, serializeAws_json1_1EvaluateExpressionCommand, } from "../protocols/Aws_json1_1";
-export class EvaluateExpressionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var EvaluateExpressionCommand = (function (_super) {
+    __extends(EvaluateExpressionCommand, _super);
+    function EvaluateExpressionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    EvaluateExpressionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataPipelineClient";
-        const commandName = "EvaluateExpressionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: EvaluateExpressionInputFilterSensitiveLog,
             outputFilterSensitiveLog: EvaluateExpressionOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    EvaluateExpressionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1EvaluateExpressionCommand(output, context);
-    }
-}
+    };
+    return EvaluateExpressionCommand;
+}($Command));
+export { EvaluateExpressionCommand };

package/dist-es/commands/GetPipelineDefinitionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetPipelineDefinitionInputFilterSensitiveLog, GetPipelineDefinitionOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetPipelineDefinitionCommand, serializeAws_json1_1GetPipelineDefinitionCommand, } from "../protocols/Aws_json1_1";
-export class GetPipelineDefinitionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetPipelineDefinitionCommand = (function (_super) {
+    __extends(GetPipelineDefinitionCommand, _super);
+    function GetPipelineDefinitionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetPipelineDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataPipelineClient";
-        const commandName = "GetPipelineDefinitionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetPipelineDefinitionInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetPipelineDefinitionOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    GetPipelineDefinitionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetPipelineDefinitionCommand(output, context);
-    }
-}
+    };
+    return GetPipelineDefinitionCommand;
+}($Command));
+export { GetPipelineDefinitionCommand };

package/dist-es/commands/ListPipelinesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListPipelinesInputFilterSensitiveLog, ListPipelinesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListPipelinesCommand, serializeAws_json1_1ListPipelinesCommand, } from "../protocols/Aws_json1_1";
-export class ListPipelinesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListPipelinesCommand = (function (_super) {
+    __extends(ListPipelinesCommand, _super);
+    function ListPipelinesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListPipelinesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataPipelineClient";
-        const commandName = "ListPipelinesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListPipelinesInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListPipelinesOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListPipelinesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListPipelinesCommand(output, context);
-    }
-}
+    };
+    return ListPipelinesCommand;
+}($Command));
+export { ListPipelinesCommand };

package/dist-es/commands/PollForTaskCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PollForTaskInputFilterSensitiveLog, PollForTaskOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1PollForTaskCommand, serializeAws_json1_1PollForTaskCommand, } from "../protocols/Aws_json1_1";
-export class PollForTaskCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PollForTaskCommand = (function (_super) {
+    __extends(PollForTaskCommand, _super);
+    function PollForTaskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PollForTaskCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataPipelineClient";
-        const commandName = "PollForTaskCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: PollForTaskInputFilterSensitiveLog,
             outputFilterSensitiveLog: PollForTaskOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    PollForTaskCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1PollForTaskCommand(output, context);
-    }
-}
+    };
+    return PollForTaskCommand;
+}($Command));
+export { PollForTaskCommand };

package/dist-es/commands/PutPipelineDefinitionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PutPipelineDefinitionInputFilterSensitiveLog, PutPipelineDefinitionOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1PutPipelineDefinitionCommand, serializeAws_json1_1PutPipelineDefinitionCommand, } from "../protocols/Aws_json1_1";
-export class PutPipelineDefinitionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutPipelineDefinitionCommand = (function (_super) {
+    __extends(PutPipelineDefinitionCommand, _super);
+    function PutPipelineDefinitionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutPipelineDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataPipelineClient";
-        const commandName = "PutPipelineDefinitionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: PutPipelineDefinitionInputFilterSensitiveLog,
             outputFilterSensitiveLog: PutPipelineDefinitionOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    PutPipelineDefinitionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1PutPipelineDefinitionCommand(output, context);
-    }
-}
+    };
+    return PutPipelineDefinitionCommand;
+}($Command));
+export { PutPipelineDefinitionCommand };

package/dist-es/commands/QueryObjectsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { QueryObjectsInputFilterSensitiveLog, QueryObjectsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1QueryObjectsCommand, serializeAws_json1_1QueryObjectsCommand, } from "../protocols/Aws_json1_1";
-export class QueryObjectsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var QueryObjectsCommand = (function (_super) {
+    __extends(QueryObjectsCommand, _super);
+    function QueryObjectsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    QueryObjectsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataPipelineClient";
-        const commandName = "QueryObjectsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: QueryObjectsInputFilterSensitiveLog,
             outputFilterSensitiveLog: QueryObjectsOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    QueryObjectsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1QueryObjectsCommand(output, context);
-    }
-}
+    };
+    return QueryObjectsCommand;
+}($Command));
+export { QueryObjectsCommand };