@aws-sdk/client-codepipeline 3.183.0 → 3.185.0

package/dist-es/commands/PutThirdPartyJobSuccessResultCommand.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 { PutThirdPartyJobSuccessResultInputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1PutThirdPartyJobSuccessResultCommand, serializeAws_json1_1PutThirdPartyJobSuccessResultCommand, } from "../protocols/Aws_json1_1";
-export class PutThirdPartyJobSuccessResultCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutThirdPartyJobSuccessResultCommand = (function (_super) {
+    __extends(PutThirdPartyJobSuccessResultCommand, _super);
+    function PutThirdPartyJobSuccessResultCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutThirdPartyJobSuccessResultCommand.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 = "CodePipelineClient";
-        const commandName = "PutThirdPartyJobSuccessResultCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CodePipelineClient";
+        var commandName = "PutThirdPartyJobSuccessResultCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutThirdPartyJobSuccessResultInputFilterSensitiveLog,
-            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);
+    };
+    PutThirdPartyJobSuccessResultCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1PutThirdPartyJobSuccessResultCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutThirdPartyJobSuccessResultCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1PutThirdPartyJobSuccessResultCommand(output, context);
-    }
-}
+    };
+    return PutThirdPartyJobSuccessResultCommand;
+}($Command));
+export { PutThirdPartyJobSuccessResultCommand };

package/dist-es/commands/PutWebhookCommand.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 { PutWebhookInputFilterSensitiveLog, PutWebhookOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1PutWebhookCommand, serializeAws_json1_1PutWebhookCommand, } from "../protocols/Aws_json1_1";
-export class PutWebhookCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutWebhookCommand = (function (_super) {
+    __extends(PutWebhookCommand, _super);
+    function PutWebhookCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutWebhookCommand.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 = "CodePipelineClient";
-        const commandName = "PutWebhookCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CodePipelineClient";
+        var commandName = "PutWebhookCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutWebhookInputFilterSensitiveLog,
             outputFilterSensitiveLog: PutWebhookOutputFilterSensitiveLog,
         };
-        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);
+    };
+    PutWebhookCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1PutWebhookCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutWebhookCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1PutWebhookCommand(output, context);
-    }
-}
+    };
+    return PutWebhookCommand;
+}($Command));
+export { PutWebhookCommand };

package/dist-es/commands/RegisterWebhookWithThirdPartyCommand.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 { RegisterWebhookWithThirdPartyInputFilterSensitiveLog, RegisterWebhookWithThirdPartyOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1RegisterWebhookWithThirdPartyCommand, serializeAws_json1_1RegisterWebhookWithThirdPartyCommand, } from "../protocols/Aws_json1_1";
-export class RegisterWebhookWithThirdPartyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RegisterWebhookWithThirdPartyCommand = (function (_super) {
+    __extends(RegisterWebhookWithThirdPartyCommand, _super);
+    function RegisterWebhookWithThirdPartyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RegisterWebhookWithThirdPartyCommand.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 = "CodePipelineClient";
-        const commandName = "RegisterWebhookWithThirdPartyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CodePipelineClient";
+        var commandName = "RegisterWebhookWithThirdPartyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RegisterWebhookWithThirdPartyInputFilterSensitiveLog,
             outputFilterSensitiveLog: RegisterWebhookWithThirdPartyOutputFilterSensitiveLog,
         };
-        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);
+    };
+    RegisterWebhookWithThirdPartyCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1RegisterWebhookWithThirdPartyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RegisterWebhookWithThirdPartyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1RegisterWebhookWithThirdPartyCommand(output, context);
-    }
-}
+    };
+    return RegisterWebhookWithThirdPartyCommand;
+}($Command));
+export { RegisterWebhookWithThirdPartyCommand };

package/dist-es/commands/RetryStageExecutionCommand.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 { RetryStageExecutionInputFilterSensitiveLog, RetryStageExecutionOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1RetryStageExecutionCommand, serializeAws_json1_1RetryStageExecutionCommand, } from "../protocols/Aws_json1_1";
-export class RetryStageExecutionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RetryStageExecutionCommand = (function (_super) {
+    __extends(RetryStageExecutionCommand, _super);
+    function RetryStageExecutionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RetryStageExecutionCommand.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 = "CodePipelineClient";
-        const commandName = "RetryStageExecutionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CodePipelineClient";
+        var commandName = "RetryStageExecutionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RetryStageExecutionInputFilterSensitiveLog,
             outputFilterSensitiveLog: RetryStageExecutionOutputFilterSensitiveLog,
         };
-        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);
+    };
+    RetryStageExecutionCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1RetryStageExecutionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RetryStageExecutionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1RetryStageExecutionCommand(output, context);
-    }
-}
+    };
+    return RetryStageExecutionCommand;
+}($Command));
+export { RetryStageExecutionCommand };

package/dist-es/commands/StartPipelineExecutionCommand.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 { StartPipelineExecutionInputFilterSensitiveLog, StartPipelineExecutionOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StartPipelineExecutionCommand, serializeAws_json1_1StartPipelineExecutionCommand, } from "../protocols/Aws_json1_1";
-export class StartPipelineExecutionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartPipelineExecutionCommand = (function (_super) {
+    __extends(StartPipelineExecutionCommand, _super);
+    function StartPipelineExecutionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartPipelineExecutionCommand.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 = "CodePipelineClient";
-        const commandName = "StartPipelineExecutionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CodePipelineClient";
+        var commandName = "StartPipelineExecutionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartPipelineExecutionInputFilterSensitiveLog,
             outputFilterSensitiveLog: StartPipelineExecutionOutputFilterSensitiveLog,
         };
-        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);
+    };
+    StartPipelineExecutionCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartPipelineExecutionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartPipelineExecutionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartPipelineExecutionCommand(output, context);
-    }
-}
+    };
+    return StartPipelineExecutionCommand;
+}($Command));
+export { StartPipelineExecutionCommand };

package/dist-es/commands/StopPipelineExecutionCommand.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 { StopPipelineExecutionInputFilterSensitiveLog, StopPipelineExecutionOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StopPipelineExecutionCommand, serializeAws_json1_1StopPipelineExecutionCommand, } from "../protocols/Aws_json1_1";
-export class StopPipelineExecutionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StopPipelineExecutionCommand = (function (_super) {
+    __extends(StopPipelineExecutionCommand, _super);
+    function StopPipelineExecutionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StopPipelineExecutionCommand.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 = "CodePipelineClient";
-        const commandName = "StopPipelineExecutionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CodePipelineClient";
+        var commandName = "StopPipelineExecutionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StopPipelineExecutionInputFilterSensitiveLog,
             outputFilterSensitiveLog: StopPipelineExecutionOutputFilterSensitiveLog,
         };
-        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);
+    };
+    StopPipelineExecutionCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StopPipelineExecutionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StopPipelineExecutionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StopPipelineExecutionCommand(output, context);
-    }
-}
+    };
+    return StopPipelineExecutionCommand;
+}($Command));
+export { StopPipelineExecutionCommand };

package/dist-es/commands/TagResourceCommand.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 { TagResourceInputFilterSensitiveLog, TagResourceOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1TagResourceCommand, serializeAws_json1_1TagResourceCommand, } from "../protocols/Aws_json1_1";
-export class TagResourceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var TagResourceCommand = (function (_super) {
+    __extends(TagResourceCommand, _super);
+    function TagResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    TagResourceCommand.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 = "CodePipelineClient";
-        const commandName = "TagResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CodePipelineClient";
+        var commandName = "TagResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: TagResourceInputFilterSensitiveLog,
             outputFilterSensitiveLog: TagResourceOutputFilterSensitiveLog,
         };
-        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);
+    };
+    TagResourceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1TagResourceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    TagResourceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1TagResourceCommand(output, context);
-    }
-}
+    };
+    return TagResourceCommand;
+}($Command));
+export { TagResourceCommand };

package/dist-es/commands/UntagResourceCommand.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 { UntagResourceInputFilterSensitiveLog, UntagResourceOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1UntagResourceCommand, serializeAws_json1_1UntagResourceCommand, } from "../protocols/Aws_json1_1";
-export class UntagResourceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UntagResourceCommand = (function (_super) {
+    __extends(UntagResourceCommand, _super);
+    function UntagResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UntagResourceCommand.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 = "CodePipelineClient";
-        const commandName = "UntagResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CodePipelineClient";
+        var commandName = "UntagResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UntagResourceInputFilterSensitiveLog,
             outputFilterSensitiveLog: UntagResourceOutputFilterSensitiveLog,
         };
-        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);
+    };
+    UntagResourceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1UntagResourceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UntagResourceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1UntagResourceCommand(output, context);
-    }
-}
+    };
+    return UntagResourceCommand;
+}($Command));
+export { UntagResourceCommand };

package/dist-es/commands/UpdateActionTypeCommand.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 { UpdateActionTypeInputFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_json1_1UpdateActionTypeCommand, serializeAws_json1_1UpdateActionTypeCommand, } from "../protocols/Aws_json1_1";
-export class UpdateActionTypeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateActionTypeCommand = (function (_super) {
+    __extends(UpdateActionTypeCommand, _super);
+    function UpdateActionTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateActionTypeCommand.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 = "CodePipelineClient";
-        const commandName = "UpdateActionTypeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CodePipelineClient";
+        var commandName = "UpdateActionTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateActionTypeInputFilterSensitiveLog,
-            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);
+    };
+    UpdateActionTypeCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1UpdateActionTypeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateActionTypeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1UpdateActionTypeCommand(output, context);
-    }
-}
+    };
+    return UpdateActionTypeCommand;
+}($Command));
+export { UpdateActionTypeCommand };

package/dist-es/commands/UpdatePipelineCommand.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 { UpdatePipelineInputFilterSensitiveLog, UpdatePipelineOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1UpdatePipelineCommand, serializeAws_json1_1UpdatePipelineCommand, } from "../protocols/Aws_json1_1";
-export class UpdatePipelineCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdatePipelineCommand = (function (_super) {
+    __extends(UpdatePipelineCommand, _super);
+    function UpdatePipelineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdatePipelineCommand.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 = "CodePipelineClient";
-        const commandName = "UpdatePipelineCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CodePipelineClient";
+        var commandName = "UpdatePipelineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdatePipelineInputFilterSensitiveLog,
             outputFilterSensitiveLog: UpdatePipelineOutputFilterSensitiveLog,
         };
-        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);
+    };
+    UpdatePipelineCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1UpdatePipelineCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdatePipelineCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1UpdatePipelineCommand(output, context);
-    }
-}
+    };
+    return UpdatePipelineCommand;
+}($Command));
+export { UpdatePipelineCommand };