@aws-sdk/client-codecommit 3.186.0 → 3.190.0

package/dist-es/CodeCommit.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { CodeCommitClient } from "./CodeCommitClient";
 import { AssociateApprovalRuleTemplateWithRepositoryCommand, } from "./commands/AssociateApprovalRuleTemplateWithRepositoryCommand";
 import { BatchAssociateApprovalRuleTemplateWithRepositoriesCommand, } from "./commands/BatchAssociateApprovalRuleTemplateWithRepositoriesCommand";
@@ -77,1089 +76,1083 @@ import { UpdatePullRequestStatusCommand, } from "./commands/UpdatePullRequestSta
 import { UpdatePullRequestTitleCommand, } from "./commands/UpdatePullRequestTitleCommand";
 import { UpdateRepositoryDescriptionCommand, } from "./commands/UpdateRepositoryDescriptionCommand";
 import { UpdateRepositoryNameCommand, } from "./commands/UpdateRepositoryNameCommand";
-var CodeCommit = (function (_super) {
-    __extends(CodeCommit, _super);
-    function CodeCommit() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    CodeCommit.prototype.associateApprovalRuleTemplateWithRepository = function (args, optionsOrCb, cb) {
-        var command = new AssociateApprovalRuleTemplateWithRepositoryCommand(args);
+export class CodeCommit extends CodeCommitClient {
+    associateApprovalRuleTemplateWithRepository(args, optionsOrCb, cb) {
+        const command = new AssociateApprovalRuleTemplateWithRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.batchAssociateApprovalRuleTemplateWithRepositories = function (args, optionsOrCb, cb) {
-        var command = new BatchAssociateApprovalRuleTemplateWithRepositoriesCommand(args);
+    }
+    batchAssociateApprovalRuleTemplateWithRepositories(args, optionsOrCb, cb) {
+        const command = new BatchAssociateApprovalRuleTemplateWithRepositoriesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.batchDescribeMergeConflicts = function (args, optionsOrCb, cb) {
-        var command = new BatchDescribeMergeConflictsCommand(args);
+    }
+    batchDescribeMergeConflicts(args, optionsOrCb, cb) {
+        const command = new BatchDescribeMergeConflictsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.batchDisassociateApprovalRuleTemplateFromRepositories = function (args, optionsOrCb, cb) {
-        var command = new BatchDisassociateApprovalRuleTemplateFromRepositoriesCommand(args);
+    }
+    batchDisassociateApprovalRuleTemplateFromRepositories(args, optionsOrCb, cb) {
+        const command = new BatchDisassociateApprovalRuleTemplateFromRepositoriesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.batchGetCommits = function (args, optionsOrCb, cb) {
-        var command = new BatchGetCommitsCommand(args);
+    }
+    batchGetCommits(args, optionsOrCb, cb) {
+        const command = new BatchGetCommitsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.batchGetRepositories = function (args, optionsOrCb, cb) {
-        var command = new BatchGetRepositoriesCommand(args);
+    }
+    batchGetRepositories(args, optionsOrCb, cb) {
+        const command = new BatchGetRepositoriesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.createApprovalRuleTemplate = function (args, optionsOrCb, cb) {
-        var command = new CreateApprovalRuleTemplateCommand(args);
+    }
+    createApprovalRuleTemplate(args, optionsOrCb, cb) {
+        const command = new CreateApprovalRuleTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.createBranch = function (args, optionsOrCb, cb) {
-        var command = new CreateBranchCommand(args);
+    }
+    createBranch(args, optionsOrCb, cb) {
+        const command = new CreateBranchCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.createCommit = function (args, optionsOrCb, cb) {
-        var command = new CreateCommitCommand(args);
+    }
+    createCommit(args, optionsOrCb, cb) {
+        const command = new CreateCommitCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.createPullRequest = function (args, optionsOrCb, cb) {
-        var command = new CreatePullRequestCommand(args);
+    }
+    createPullRequest(args, optionsOrCb, cb) {
+        const command = new CreatePullRequestCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.createPullRequestApprovalRule = function (args, optionsOrCb, cb) {
-        var command = new CreatePullRequestApprovalRuleCommand(args);
+    }
+    createPullRequestApprovalRule(args, optionsOrCb, cb) {
+        const command = new CreatePullRequestApprovalRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.createRepository = function (args, optionsOrCb, cb) {
-        var command = new CreateRepositoryCommand(args);
+    }
+    createRepository(args, optionsOrCb, cb) {
+        const command = new CreateRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.createUnreferencedMergeCommit = function (args, optionsOrCb, cb) {
-        var command = new CreateUnreferencedMergeCommitCommand(args);
+    }
+    createUnreferencedMergeCommit(args, optionsOrCb, cb) {
+        const command = new CreateUnreferencedMergeCommitCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.deleteApprovalRuleTemplate = function (args, optionsOrCb, cb) {
-        var command = new DeleteApprovalRuleTemplateCommand(args);
+    }
+    deleteApprovalRuleTemplate(args, optionsOrCb, cb) {
+        const command = new DeleteApprovalRuleTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.deleteBranch = function (args, optionsOrCb, cb) {
-        var command = new DeleteBranchCommand(args);
+    }
+    deleteBranch(args, optionsOrCb, cb) {
+        const command = new DeleteBranchCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.deleteCommentContent = function (args, optionsOrCb, cb) {
-        var command = new DeleteCommentContentCommand(args);
+    }
+    deleteCommentContent(args, optionsOrCb, cb) {
+        const command = new DeleteCommentContentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.deleteFile = function (args, optionsOrCb, cb) {
-        var command = new DeleteFileCommand(args);
+    }
+    deleteFile(args, optionsOrCb, cb) {
+        const command = new DeleteFileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.deletePullRequestApprovalRule = function (args, optionsOrCb, cb) {
-        var command = new DeletePullRequestApprovalRuleCommand(args);
+    }
+    deletePullRequestApprovalRule(args, optionsOrCb, cb) {
+        const command = new DeletePullRequestApprovalRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.deleteRepository = function (args, optionsOrCb, cb) {
-        var command = new DeleteRepositoryCommand(args);
+    }
+    deleteRepository(args, optionsOrCb, cb) {
+        const command = new DeleteRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.describeMergeConflicts = function (args, optionsOrCb, cb) {
-        var command = new DescribeMergeConflictsCommand(args);
+    }
+    describeMergeConflicts(args, optionsOrCb, cb) {
+        const command = new DescribeMergeConflictsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.describePullRequestEvents = function (args, optionsOrCb, cb) {
-        var command = new DescribePullRequestEventsCommand(args);
+    }
+    describePullRequestEvents(args, optionsOrCb, cb) {
+        const command = new DescribePullRequestEventsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.disassociateApprovalRuleTemplateFromRepository = function (args, optionsOrCb, cb) {
-        var command = new DisassociateApprovalRuleTemplateFromRepositoryCommand(args);
+    }
+    disassociateApprovalRuleTemplateFromRepository(args, optionsOrCb, cb) {
+        const command = new DisassociateApprovalRuleTemplateFromRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.evaluatePullRequestApprovalRules = function (args, optionsOrCb, cb) {
-        var command = new EvaluatePullRequestApprovalRulesCommand(args);
+    }
+    evaluatePullRequestApprovalRules(args, optionsOrCb, cb) {
+        const command = new EvaluatePullRequestApprovalRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getApprovalRuleTemplate = function (args, optionsOrCb, cb) {
-        var command = new GetApprovalRuleTemplateCommand(args);
+    }
+    getApprovalRuleTemplate(args, optionsOrCb, cb) {
+        const command = new GetApprovalRuleTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getBlob = function (args, optionsOrCb, cb) {
-        var command = new GetBlobCommand(args);
+    }
+    getBlob(args, optionsOrCb, cb) {
+        const command = new GetBlobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getBranch = function (args, optionsOrCb, cb) {
-        var command = new GetBranchCommand(args);
+    }
+    getBranch(args, optionsOrCb, cb) {
+        const command = new GetBranchCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getComment = function (args, optionsOrCb, cb) {
-        var command = new GetCommentCommand(args);
+    }
+    getComment(args, optionsOrCb, cb) {
+        const command = new GetCommentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getCommentReactions = function (args, optionsOrCb, cb) {
-        var command = new GetCommentReactionsCommand(args);
+    }
+    getCommentReactions(args, optionsOrCb, cb) {
+        const command = new GetCommentReactionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getCommentsForComparedCommit = function (args, optionsOrCb, cb) {
-        var command = new GetCommentsForComparedCommitCommand(args);
+    }
+    getCommentsForComparedCommit(args, optionsOrCb, cb) {
+        const command = new GetCommentsForComparedCommitCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getCommentsForPullRequest = function (args, optionsOrCb, cb) {
-        var command = new GetCommentsForPullRequestCommand(args);
+    }
+    getCommentsForPullRequest(args, optionsOrCb, cb) {
+        const command = new GetCommentsForPullRequestCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getCommit = function (args, optionsOrCb, cb) {
-        var command = new GetCommitCommand(args);
+    }
+    getCommit(args, optionsOrCb, cb) {
+        const command = new GetCommitCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getDifferences = function (args, optionsOrCb, cb) {
-        var command = new GetDifferencesCommand(args);
+    }
+    getDifferences(args, optionsOrCb, cb) {
+        const command = new GetDifferencesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getFile = function (args, optionsOrCb, cb) {
-        var command = new GetFileCommand(args);
+    }
+    getFile(args, optionsOrCb, cb) {
+        const command = new GetFileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getFolder = function (args, optionsOrCb, cb) {
-        var command = new GetFolderCommand(args);
+    }
+    getFolder(args, optionsOrCb, cb) {
+        const command = new GetFolderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getMergeCommit = function (args, optionsOrCb, cb) {
-        var command = new GetMergeCommitCommand(args);
+    }
+    getMergeCommit(args, optionsOrCb, cb) {
+        const command = new GetMergeCommitCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getMergeConflicts = function (args, optionsOrCb, cb) {
-        var command = new GetMergeConflictsCommand(args);
+    }
+    getMergeConflicts(args, optionsOrCb, cb) {
+        const command = new GetMergeConflictsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getMergeOptions = function (args, optionsOrCb, cb) {
-        var command = new GetMergeOptionsCommand(args);
+    }
+    getMergeOptions(args, optionsOrCb, cb) {
+        const command = new GetMergeOptionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getPullRequest = function (args, optionsOrCb, cb) {
-        var command = new GetPullRequestCommand(args);
+    }
+    getPullRequest(args, optionsOrCb, cb) {
+        const command = new GetPullRequestCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getPullRequestApprovalStates = function (args, optionsOrCb, cb) {
-        var command = new GetPullRequestApprovalStatesCommand(args);
+    }
+    getPullRequestApprovalStates(args, optionsOrCb, cb) {
+        const command = new GetPullRequestApprovalStatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getPullRequestOverrideState = function (args, optionsOrCb, cb) {
-        var command = new GetPullRequestOverrideStateCommand(args);
+    }
+    getPullRequestOverrideState(args, optionsOrCb, cb) {
+        const command = new GetPullRequestOverrideStateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getRepository = function (args, optionsOrCb, cb) {
-        var command = new GetRepositoryCommand(args);
+    }
+    getRepository(args, optionsOrCb, cb) {
+        const command = new GetRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.getRepositoryTriggers = function (args, optionsOrCb, cb) {
-        var command = new GetRepositoryTriggersCommand(args);
+    }
+    getRepositoryTriggers(args, optionsOrCb, cb) {
+        const command = new GetRepositoryTriggersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.listApprovalRuleTemplates = function (args, optionsOrCb, cb) {
-        var command = new ListApprovalRuleTemplatesCommand(args);
+    }
+    listApprovalRuleTemplates(args, optionsOrCb, cb) {
+        const command = new ListApprovalRuleTemplatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.listAssociatedApprovalRuleTemplatesForRepository = function (args, optionsOrCb, cb) {
-        var command = new ListAssociatedApprovalRuleTemplatesForRepositoryCommand(args);
+    }
+    listAssociatedApprovalRuleTemplatesForRepository(args, optionsOrCb, cb) {
+        const command = new ListAssociatedApprovalRuleTemplatesForRepositoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.listBranches = function (args, optionsOrCb, cb) {
-        var command = new ListBranchesCommand(args);
+    }
+    listBranches(args, optionsOrCb, cb) {
+        const command = new ListBranchesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.listPullRequests = function (args, optionsOrCb, cb) {
-        var command = new ListPullRequestsCommand(args);
+    }
+    listPullRequests(args, optionsOrCb, cb) {
+        const command = new ListPullRequestsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.listRepositories = function (args, optionsOrCb, cb) {
-        var command = new ListRepositoriesCommand(args);
+    }
+    listRepositories(args, optionsOrCb, cb) {
+        const command = new ListRepositoriesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.listRepositoriesForApprovalRuleTemplate = function (args, optionsOrCb, cb) {
-        var command = new ListRepositoriesForApprovalRuleTemplateCommand(args);
+    }
+    listRepositoriesForApprovalRuleTemplate(args, optionsOrCb, cb) {
+        const command = new ListRepositoriesForApprovalRuleTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
-        var command = new ListTagsForResourceCommand(args);
+    }
+    listTagsForResource(args, optionsOrCb, cb) {
+        const command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.mergeBranchesByFastForward = function (args, optionsOrCb, cb) {
-        var command = new MergeBranchesByFastForwardCommand(args);
+    }
+    mergeBranchesByFastForward(args, optionsOrCb, cb) {
+        const command = new MergeBranchesByFastForwardCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.mergeBranchesBySquash = function (args, optionsOrCb, cb) {
-        var command = new MergeBranchesBySquashCommand(args);
+    }
+    mergeBranchesBySquash(args, optionsOrCb, cb) {
+        const command = new MergeBranchesBySquashCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.mergeBranchesByThreeWay = function (args, optionsOrCb, cb) {
-        var command = new MergeBranchesByThreeWayCommand(args);
+    }
+    mergeBranchesByThreeWay(args, optionsOrCb, cb) {
+        const command = new MergeBranchesByThreeWayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.mergePullRequestByFastForward = function (args, optionsOrCb, cb) {
-        var command = new MergePullRequestByFastForwardCommand(args);
+    }
+    mergePullRequestByFastForward(args, optionsOrCb, cb) {
+        const command = new MergePullRequestByFastForwardCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.mergePullRequestBySquash = function (args, optionsOrCb, cb) {
-        var command = new MergePullRequestBySquashCommand(args);
+    }
+    mergePullRequestBySquash(args, optionsOrCb, cb) {
+        const command = new MergePullRequestBySquashCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.mergePullRequestByThreeWay = function (args, optionsOrCb, cb) {
-        var command = new MergePullRequestByThreeWayCommand(args);
+    }
+    mergePullRequestByThreeWay(args, optionsOrCb, cb) {
+        const command = new MergePullRequestByThreeWayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.overridePullRequestApprovalRules = function (args, optionsOrCb, cb) {
-        var command = new OverridePullRequestApprovalRulesCommand(args);
+    }
+    overridePullRequestApprovalRules(args, optionsOrCb, cb) {
+        const command = new OverridePullRequestApprovalRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.postCommentForComparedCommit = function (args, optionsOrCb, cb) {
-        var command = new PostCommentForComparedCommitCommand(args);
+    }
+    postCommentForComparedCommit(args, optionsOrCb, cb) {
+        const command = new PostCommentForComparedCommitCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.postCommentForPullRequest = function (args, optionsOrCb, cb) {
-        var command = new PostCommentForPullRequestCommand(args);
+    }
+    postCommentForPullRequest(args, optionsOrCb, cb) {
+        const command = new PostCommentForPullRequestCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.postCommentReply = function (args, optionsOrCb, cb) {
-        var command = new PostCommentReplyCommand(args);
+    }
+    postCommentReply(args, optionsOrCb, cb) {
+        const command = new PostCommentReplyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.putCommentReaction = function (args, optionsOrCb, cb) {
-        var command = new PutCommentReactionCommand(args);
+    }
+    putCommentReaction(args, optionsOrCb, cb) {
+        const command = new PutCommentReactionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.putFile = function (args, optionsOrCb, cb) {
-        var command = new PutFileCommand(args);
+    }
+    putFile(args, optionsOrCb, cb) {
+        const command = new PutFileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.putRepositoryTriggers = function (args, optionsOrCb, cb) {
-        var command = new PutRepositoryTriggersCommand(args);
+    }
+    putRepositoryTriggers(args, optionsOrCb, cb) {
+        const command = new PutRepositoryTriggersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.tagResource = function (args, optionsOrCb, cb) {
-        var command = new TagResourceCommand(args);
+    }
+    tagResource(args, optionsOrCb, cb) {
+        const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.testRepositoryTriggers = function (args, optionsOrCb, cb) {
-        var command = new TestRepositoryTriggersCommand(args);
+    }
+    testRepositoryTriggers(args, optionsOrCb, cb) {
+        const command = new TestRepositoryTriggersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.untagResource = function (args, optionsOrCb, cb) {
-        var command = new UntagResourceCommand(args);
+    }
+    untagResource(args, optionsOrCb, cb) {
+        const command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updateApprovalRuleTemplateContent = function (args, optionsOrCb, cb) {
-        var command = new UpdateApprovalRuleTemplateContentCommand(args);
+    }
+    updateApprovalRuleTemplateContent(args, optionsOrCb, cb) {
+        const command = new UpdateApprovalRuleTemplateContentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updateApprovalRuleTemplateDescription = function (args, optionsOrCb, cb) {
-        var command = new UpdateApprovalRuleTemplateDescriptionCommand(args);
+    }
+    updateApprovalRuleTemplateDescription(args, optionsOrCb, cb) {
+        const command = new UpdateApprovalRuleTemplateDescriptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updateApprovalRuleTemplateName = function (args, optionsOrCb, cb) {
-        var command = new UpdateApprovalRuleTemplateNameCommand(args);
+    }
+    updateApprovalRuleTemplateName(args, optionsOrCb, cb) {
+        const command = new UpdateApprovalRuleTemplateNameCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updateComment = function (args, optionsOrCb, cb) {
-        var command = new UpdateCommentCommand(args);
+    }
+    updateComment(args, optionsOrCb, cb) {
+        const command = new UpdateCommentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updateDefaultBranch = function (args, optionsOrCb, cb) {
-        var command = new UpdateDefaultBranchCommand(args);
+    }
+    updateDefaultBranch(args, optionsOrCb, cb) {
+        const command = new UpdateDefaultBranchCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updatePullRequestApprovalRuleContent = function (args, optionsOrCb, cb) {
-        var command = new UpdatePullRequestApprovalRuleContentCommand(args);
+    }
+    updatePullRequestApprovalRuleContent(args, optionsOrCb, cb) {
+        const command = new UpdatePullRequestApprovalRuleContentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updatePullRequestApprovalState = function (args, optionsOrCb, cb) {
-        var command = new UpdatePullRequestApprovalStateCommand(args);
+    }
+    updatePullRequestApprovalState(args, optionsOrCb, cb) {
+        const command = new UpdatePullRequestApprovalStateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updatePullRequestDescription = function (args, optionsOrCb, cb) {
-        var command = new UpdatePullRequestDescriptionCommand(args);
+    }
+    updatePullRequestDescription(args, optionsOrCb, cb) {
+        const command = new UpdatePullRequestDescriptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updatePullRequestStatus = function (args, optionsOrCb, cb) {
-        var command = new UpdatePullRequestStatusCommand(args);
+    }
+    updatePullRequestStatus(args, optionsOrCb, cb) {
+        const command = new UpdatePullRequestStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updatePullRequestTitle = function (args, optionsOrCb, cb) {
-        var command = new UpdatePullRequestTitleCommand(args);
+    }
+    updatePullRequestTitle(args, optionsOrCb, cb) {
+        const command = new UpdatePullRequestTitleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updateRepositoryDescription = function (args, optionsOrCb, cb) {
-        var command = new UpdateRepositoryDescriptionCommand(args);
+    }
+    updateRepositoryDescription(args, optionsOrCb, cb) {
+        const command = new UpdateRepositoryDescriptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CodeCommit.prototype.updateRepositoryName = function (args, optionsOrCb, cb) {
-        var command = new UpdateRepositoryNameCommand(args);
+    }
+    updateRepositoryName(args, optionsOrCb, cb) {
+        const command = new UpdateRepositoryNameCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    return CodeCommit;
-}(CodeCommitClient));
-export { CodeCommit };
+    }
+}