@aws-sdk/client-codecommit 3.183.0 → 3.185.0

package/dist-es/CodeCommit.js

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