@aws-sdk/client-codecommit 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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