@aws-sdk/client-api-gateway 3.183.0 → 3.185.0

package/dist-es/APIGateway.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { APIGatewayClient } from "./APIGatewayClient";
 import { CreateApiKeyCommand, } from "./commands/CreateApiKeyCommand";
 import { CreateAuthorizerCommand, } from "./commands/CreateAuthorizerCommand";
@@ -119,1685 +120,1691 @@ import { UpdateStageCommand } from "./commands/UpdateStageCommand";
 import { UpdateUsageCommand } from "./commands/UpdateUsageCommand";
 import { UpdateUsagePlanCommand, } from "./commands/UpdateUsagePlanCommand";
 import { UpdateVpcLinkCommand, } from "./commands/UpdateVpcLinkCommand";
-export class APIGateway extends APIGatewayClient {
-    createApiKey(args, optionsOrCb, cb) {
-        const command = new CreateApiKeyCommand(args);
+var APIGateway = (function (_super) {
+    __extends(APIGateway, _super);
+    function APIGateway() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    APIGateway.prototype.createApiKey = function (args, optionsOrCb, cb) {
+        var command = new CreateApiKeyCommand(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);
         }
-    }
-    createAuthorizer(args, optionsOrCb, cb) {
-        const command = new CreateAuthorizerCommand(args);
+    };
+    APIGateway.prototype.createAuthorizer = function (args, optionsOrCb, cb) {
+        var command = new CreateAuthorizerCommand(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);
         }
-    }
-    createBasePathMapping(args, optionsOrCb, cb) {
-        const command = new CreateBasePathMappingCommand(args);
+    };
+    APIGateway.prototype.createBasePathMapping = function (args, optionsOrCb, cb) {
+        var command = new CreateBasePathMappingCommand(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);
         }
-    }
-    createDeployment(args, optionsOrCb, cb) {
-        const command = new CreateDeploymentCommand(args);
+    };
+    APIGateway.prototype.createDeployment = function (args, optionsOrCb, cb) {
+        var command = new CreateDeploymentCommand(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);
         }
-    }
-    createDocumentationPart(args, optionsOrCb, cb) {
-        const command = new CreateDocumentationPartCommand(args);
+    };
+    APIGateway.prototype.createDocumentationPart = function (args, optionsOrCb, cb) {
+        var command = new CreateDocumentationPartCommand(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);
         }
-    }
-    createDocumentationVersion(args, optionsOrCb, cb) {
-        const command = new CreateDocumentationVersionCommand(args);
+    };
+    APIGateway.prototype.createDocumentationVersion = function (args, optionsOrCb, cb) {
+        var command = new CreateDocumentationVersionCommand(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);
         }
-    }
-    createDomainName(args, optionsOrCb, cb) {
-        const command = new CreateDomainNameCommand(args);
+    };
+    APIGateway.prototype.createDomainName = function (args, optionsOrCb, cb) {
+        var command = new CreateDomainNameCommand(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);
         }
-    }
-    createModel(args, optionsOrCb, cb) {
-        const command = new CreateModelCommand(args);
+    };
+    APIGateway.prototype.createModel = function (args, optionsOrCb, cb) {
+        var command = new CreateModelCommand(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);
         }
-    }
-    createRequestValidator(args, optionsOrCb, cb) {
-        const command = new CreateRequestValidatorCommand(args);
+    };
+    APIGateway.prototype.createRequestValidator = function (args, optionsOrCb, cb) {
+        var command = new CreateRequestValidatorCommand(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);
         }
-    }
-    createResource(args, optionsOrCb, cb) {
-        const command = new CreateResourceCommand(args);
+    };
+    APIGateway.prototype.createResource = function (args, optionsOrCb, cb) {
+        var command = new CreateResourceCommand(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);
         }
-    }
-    createRestApi(args, optionsOrCb, cb) {
-        const command = new CreateRestApiCommand(args);
+    };
+    APIGateway.prototype.createRestApi = function (args, optionsOrCb, cb) {
+        var command = new CreateRestApiCommand(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);
         }
-    }
-    createStage(args, optionsOrCb, cb) {
-        const command = new CreateStageCommand(args);
+    };
+    APIGateway.prototype.createStage = function (args, optionsOrCb, cb) {
+        var command = new CreateStageCommand(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);
         }
-    }
-    createUsagePlan(args, optionsOrCb, cb) {
-        const command = new CreateUsagePlanCommand(args);
+    };
+    APIGateway.prototype.createUsagePlan = function (args, optionsOrCb, cb) {
+        var command = new CreateUsagePlanCommand(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);
         }
-    }
-    createUsagePlanKey(args, optionsOrCb, cb) {
-        const command = new CreateUsagePlanKeyCommand(args);
+    };
+    APIGateway.prototype.createUsagePlanKey = function (args, optionsOrCb, cb) {
+        var command = new CreateUsagePlanKeyCommand(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);
         }
-    }
-    createVpcLink(args, optionsOrCb, cb) {
-        const command = new CreateVpcLinkCommand(args);
+    };
+    APIGateway.prototype.createVpcLink = function (args, optionsOrCb, cb) {
+        var command = new CreateVpcLinkCommand(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);
         }
-    }
-    deleteApiKey(args, optionsOrCb, cb) {
-        const command = new DeleteApiKeyCommand(args);
+    };
+    APIGateway.prototype.deleteApiKey = function (args, optionsOrCb, cb) {
+        var command = new DeleteApiKeyCommand(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);
         }
-    }
-    deleteAuthorizer(args, optionsOrCb, cb) {
-        const command = new DeleteAuthorizerCommand(args);
+    };
+    APIGateway.prototype.deleteAuthorizer = function (args, optionsOrCb, cb) {
+        var command = new DeleteAuthorizerCommand(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);
         }
-    }
-    deleteBasePathMapping(args, optionsOrCb, cb) {
-        const command = new DeleteBasePathMappingCommand(args);
+    };
+    APIGateway.prototype.deleteBasePathMapping = function (args, optionsOrCb, cb) {
+        var command = new DeleteBasePathMappingCommand(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);
         }
-    }
-    deleteClientCertificate(args, optionsOrCb, cb) {
-        const command = new DeleteClientCertificateCommand(args);
+    };
+    APIGateway.prototype.deleteClientCertificate = function (args, optionsOrCb, cb) {
+        var command = new DeleteClientCertificateCommand(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);
         }
-    }
-    deleteDeployment(args, optionsOrCb, cb) {
-        const command = new DeleteDeploymentCommand(args);
+    };
+    APIGateway.prototype.deleteDeployment = function (args, optionsOrCb, cb) {
+        var command = new DeleteDeploymentCommand(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);
         }
-    }
-    deleteDocumentationPart(args, optionsOrCb, cb) {
-        const command = new DeleteDocumentationPartCommand(args);
+    };
+    APIGateway.prototype.deleteDocumentationPart = function (args, optionsOrCb, cb) {
+        var command = new DeleteDocumentationPartCommand(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);
         }
-    }
-    deleteDocumentationVersion(args, optionsOrCb, cb) {
-        const command = new DeleteDocumentationVersionCommand(args);
+    };
+    APIGateway.prototype.deleteDocumentationVersion = function (args, optionsOrCb, cb) {
+        var command = new DeleteDocumentationVersionCommand(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);
         }
-    }
-    deleteDomainName(args, optionsOrCb, cb) {
-        const command = new DeleteDomainNameCommand(args);
+    };
+    APIGateway.prototype.deleteDomainName = function (args, optionsOrCb, cb) {
+        var command = new DeleteDomainNameCommand(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);
         }
-    }
-    deleteGatewayResponse(args, optionsOrCb, cb) {
-        const command = new DeleteGatewayResponseCommand(args);
+    };
+    APIGateway.prototype.deleteGatewayResponse = function (args, optionsOrCb, cb) {
+        var command = new DeleteGatewayResponseCommand(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);
         }
-    }
-    deleteIntegration(args, optionsOrCb, cb) {
-        const command = new DeleteIntegrationCommand(args);
+    };
+    APIGateway.prototype.deleteIntegration = function (args, optionsOrCb, cb) {
+        var command = new DeleteIntegrationCommand(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);
         }
-    }
-    deleteIntegrationResponse(args, optionsOrCb, cb) {
-        const command = new DeleteIntegrationResponseCommand(args);
+    };
+    APIGateway.prototype.deleteIntegrationResponse = function (args, optionsOrCb, cb) {
+        var command = new DeleteIntegrationResponseCommand(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);
         }
-    }
-    deleteMethod(args, optionsOrCb, cb) {
-        const command = new DeleteMethodCommand(args);
+    };
+    APIGateway.prototype.deleteMethod = function (args, optionsOrCb, cb) {
+        var command = new DeleteMethodCommand(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);
         }
-    }
-    deleteMethodResponse(args, optionsOrCb, cb) {
-        const command = new DeleteMethodResponseCommand(args);
+    };
+    APIGateway.prototype.deleteMethodResponse = function (args, optionsOrCb, cb) {
+        var command = new DeleteMethodResponseCommand(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);
         }
-    }
-    deleteModel(args, optionsOrCb, cb) {
-        const command = new DeleteModelCommand(args);
+    };
+    APIGateway.prototype.deleteModel = function (args, optionsOrCb, cb) {
+        var command = new DeleteModelCommand(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);
         }
-    }
-    deleteRequestValidator(args, optionsOrCb, cb) {
-        const command = new DeleteRequestValidatorCommand(args);
+    };
+    APIGateway.prototype.deleteRequestValidator = function (args, optionsOrCb, cb) {
+        var command = new DeleteRequestValidatorCommand(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);
         }
-    }
-    deleteResource(args, optionsOrCb, cb) {
-        const command = new DeleteResourceCommand(args);
+    };
+    APIGateway.prototype.deleteResource = function (args, optionsOrCb, cb) {
+        var command = new DeleteResourceCommand(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);
         }
-    }
-    deleteRestApi(args, optionsOrCb, cb) {
-        const command = new DeleteRestApiCommand(args);
+    };
+    APIGateway.prototype.deleteRestApi = function (args, optionsOrCb, cb) {
+        var command = new DeleteRestApiCommand(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);
         }
-    }
-    deleteStage(args, optionsOrCb, cb) {
-        const command = new DeleteStageCommand(args);
+    };
+    APIGateway.prototype.deleteStage = function (args, optionsOrCb, cb) {
+        var command = new DeleteStageCommand(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);
         }
-    }
-    deleteUsagePlan(args, optionsOrCb, cb) {
-        const command = new DeleteUsagePlanCommand(args);
+    };
+    APIGateway.prototype.deleteUsagePlan = function (args, optionsOrCb, cb) {
+        var command = new DeleteUsagePlanCommand(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);
         }
-    }
-    deleteUsagePlanKey(args, optionsOrCb, cb) {
-        const command = new DeleteUsagePlanKeyCommand(args);
+    };
+    APIGateway.prototype.deleteUsagePlanKey = function (args, optionsOrCb, cb) {
+        var command = new DeleteUsagePlanKeyCommand(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);
         }
-    }
-    deleteVpcLink(args, optionsOrCb, cb) {
-        const command = new DeleteVpcLinkCommand(args);
+    };
+    APIGateway.prototype.deleteVpcLink = function (args, optionsOrCb, cb) {
+        var command = new DeleteVpcLinkCommand(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);
         }
-    }
-    flushStageAuthorizersCache(args, optionsOrCb, cb) {
-        const command = new FlushStageAuthorizersCacheCommand(args);
+    };
+    APIGateway.prototype.flushStageAuthorizersCache = function (args, optionsOrCb, cb) {
+        var command = new FlushStageAuthorizersCacheCommand(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);
         }
-    }
-    flushStageCache(args, optionsOrCb, cb) {
-        const command = new FlushStageCacheCommand(args);
+    };
+    APIGateway.prototype.flushStageCache = function (args, optionsOrCb, cb) {
+        var command = new FlushStageCacheCommand(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);
         }
-    }
-    generateClientCertificate(args, optionsOrCb, cb) {
-        const command = new GenerateClientCertificateCommand(args);
+    };
+    APIGateway.prototype.generateClientCertificate = function (args, optionsOrCb, cb) {
+        var command = new GenerateClientCertificateCommand(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);
         }
-    }
-    getAccount(args, optionsOrCb, cb) {
-        const command = new GetAccountCommand(args);
+    };
+    APIGateway.prototype.getAccount = function (args, optionsOrCb, cb) {
+        var command = new GetAccountCommand(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);
         }
-    }
-    getApiKey(args, optionsOrCb, cb) {
-        const command = new GetApiKeyCommand(args);
+    };
+    APIGateway.prototype.getApiKey = function (args, optionsOrCb, cb) {
+        var command = new GetApiKeyCommand(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);
         }
-    }
-    getApiKeys(args, optionsOrCb, cb) {
-        const command = new GetApiKeysCommand(args);
+    };
+    APIGateway.prototype.getApiKeys = function (args, optionsOrCb, cb) {
+        var command = new GetApiKeysCommand(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);
         }
-    }
-    getAuthorizer(args, optionsOrCb, cb) {
-        const command = new GetAuthorizerCommand(args);
+    };
+    APIGateway.prototype.getAuthorizer = function (args, optionsOrCb, cb) {
+        var command = new GetAuthorizerCommand(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);
         }
-    }
-    getAuthorizers(args, optionsOrCb, cb) {
-        const command = new GetAuthorizersCommand(args);
+    };
+    APIGateway.prototype.getAuthorizers = function (args, optionsOrCb, cb) {
+        var command = new GetAuthorizersCommand(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);
         }
-    }
-    getBasePathMapping(args, optionsOrCb, cb) {
-        const command = new GetBasePathMappingCommand(args);
+    };
+    APIGateway.prototype.getBasePathMapping = function (args, optionsOrCb, cb) {
+        var command = new GetBasePathMappingCommand(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);
         }
-    }
-    getBasePathMappings(args, optionsOrCb, cb) {
-        const command = new GetBasePathMappingsCommand(args);
+    };
+    APIGateway.prototype.getBasePathMappings = function (args, optionsOrCb, cb) {
+        var command = new GetBasePathMappingsCommand(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);
         }
-    }
-    getClientCertificate(args, optionsOrCb, cb) {
-        const command = new GetClientCertificateCommand(args);
+    };
+    APIGateway.prototype.getClientCertificate = function (args, optionsOrCb, cb) {
+        var command = new GetClientCertificateCommand(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);
         }
-    }
-    getClientCertificates(args, optionsOrCb, cb) {
-        const command = new GetClientCertificatesCommand(args);
+    };
+    APIGateway.prototype.getClientCertificates = function (args, optionsOrCb, cb) {
+        var command = new GetClientCertificatesCommand(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);
         }
-    }
-    getDeployment(args, optionsOrCb, cb) {
-        const command = new GetDeploymentCommand(args);
+    };
+    APIGateway.prototype.getDeployment = function (args, optionsOrCb, cb) {
+        var command = new GetDeploymentCommand(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);
         }
-    }
-    getDeployments(args, optionsOrCb, cb) {
-        const command = new GetDeploymentsCommand(args);
+    };
+    APIGateway.prototype.getDeployments = function (args, optionsOrCb, cb) {
+        var command = new GetDeploymentsCommand(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);
         }
-    }
-    getDocumentationPart(args, optionsOrCb, cb) {
-        const command = new GetDocumentationPartCommand(args);
+    };
+    APIGateway.prototype.getDocumentationPart = function (args, optionsOrCb, cb) {
+        var command = new GetDocumentationPartCommand(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);
         }
-    }
-    getDocumentationParts(args, optionsOrCb, cb) {
-        const command = new GetDocumentationPartsCommand(args);
+    };
+    APIGateway.prototype.getDocumentationParts = function (args, optionsOrCb, cb) {
+        var command = new GetDocumentationPartsCommand(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);
         }
-    }
-    getDocumentationVersion(args, optionsOrCb, cb) {
-        const command = new GetDocumentationVersionCommand(args);
+    };
+    APIGateway.prototype.getDocumentationVersion = function (args, optionsOrCb, cb) {
+        var command = new GetDocumentationVersionCommand(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);
         }
-    }
-    getDocumentationVersions(args, optionsOrCb, cb) {
-        const command = new GetDocumentationVersionsCommand(args);
+    };
+    APIGateway.prototype.getDocumentationVersions = function (args, optionsOrCb, cb) {
+        var command = new GetDocumentationVersionsCommand(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);
         }
-    }
-    getDomainName(args, optionsOrCb, cb) {
-        const command = new GetDomainNameCommand(args);
+    };
+    APIGateway.prototype.getDomainName = function (args, optionsOrCb, cb) {
+        var command = new GetDomainNameCommand(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);
         }
-    }
-    getDomainNames(args, optionsOrCb, cb) {
-        const command = new GetDomainNamesCommand(args);
+    };
+    APIGateway.prototype.getDomainNames = function (args, optionsOrCb, cb) {
+        var command = new GetDomainNamesCommand(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);
         }
-    }
-    getExport(args, optionsOrCb, cb) {
-        const command = new GetExportCommand(args);
+    };
+    APIGateway.prototype.getExport = function (args, optionsOrCb, cb) {
+        var command = new GetExportCommand(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);
         }
-    }
-    getGatewayResponse(args, optionsOrCb, cb) {
-        const command = new GetGatewayResponseCommand(args);
+    };
+    APIGateway.prototype.getGatewayResponse = function (args, optionsOrCb, cb) {
+        var command = new GetGatewayResponseCommand(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);
         }
-    }
-    getGatewayResponses(args, optionsOrCb, cb) {
-        const command = new GetGatewayResponsesCommand(args);
+    };
+    APIGateway.prototype.getGatewayResponses = function (args, optionsOrCb, cb) {
+        var command = new GetGatewayResponsesCommand(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);
         }
-    }
-    getIntegration(args, optionsOrCb, cb) {
-        const command = new GetIntegrationCommand(args);
+    };
+    APIGateway.prototype.getIntegration = function (args, optionsOrCb, cb) {
+        var command = new GetIntegrationCommand(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);
         }
-    }
-    getIntegrationResponse(args, optionsOrCb, cb) {
-        const command = new GetIntegrationResponseCommand(args);
+    };
+    APIGateway.prototype.getIntegrationResponse = function (args, optionsOrCb, cb) {
+        var command = new GetIntegrationResponseCommand(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);
         }
-    }
-    getMethod(args, optionsOrCb, cb) {
-        const command = new GetMethodCommand(args);
+    };
+    APIGateway.prototype.getMethod = function (args, optionsOrCb, cb) {
+        var command = new GetMethodCommand(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);
         }
-    }
-    getMethodResponse(args, optionsOrCb, cb) {
-        const command = new GetMethodResponseCommand(args);
+    };
+    APIGateway.prototype.getMethodResponse = function (args, optionsOrCb, cb) {
+        var command = new GetMethodResponseCommand(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);
         }
-    }
-    getModel(args, optionsOrCb, cb) {
-        const command = new GetModelCommand(args);
+    };
+    APIGateway.prototype.getModel = function (args, optionsOrCb, cb) {
+        var command = new GetModelCommand(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);
         }
-    }
-    getModels(args, optionsOrCb, cb) {
-        const command = new GetModelsCommand(args);
+    };
+    APIGateway.prototype.getModels = function (args, optionsOrCb, cb) {
+        var command = new GetModelsCommand(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);
         }
-    }
-    getModelTemplate(args, optionsOrCb, cb) {
-        const command = new GetModelTemplateCommand(args);
+    };
+    APIGateway.prototype.getModelTemplate = function (args, optionsOrCb, cb) {
+        var command = new GetModelTemplateCommand(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);
         }
-    }
-    getRequestValidator(args, optionsOrCb, cb) {
-        const command = new GetRequestValidatorCommand(args);
+    };
+    APIGateway.prototype.getRequestValidator = function (args, optionsOrCb, cb) {
+        var command = new GetRequestValidatorCommand(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);
         }
-    }
-    getRequestValidators(args, optionsOrCb, cb) {
-        const command = new GetRequestValidatorsCommand(args);
+    };
+    APIGateway.prototype.getRequestValidators = function (args, optionsOrCb, cb) {
+        var command = new GetRequestValidatorsCommand(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);
         }
-    }
-    getResource(args, optionsOrCb, cb) {
-        const command = new GetResourceCommand(args);
+    };
+    APIGateway.prototype.getResource = function (args, optionsOrCb, cb) {
+        var command = new GetResourceCommand(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);
         }
-    }
-    getResources(args, optionsOrCb, cb) {
-        const command = new GetResourcesCommand(args);
+    };
+    APIGateway.prototype.getResources = function (args, optionsOrCb, cb) {
+        var command = new GetResourcesCommand(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);
         }
-    }
-    getRestApi(args, optionsOrCb, cb) {
-        const command = new GetRestApiCommand(args);
+    };
+    APIGateway.prototype.getRestApi = function (args, optionsOrCb, cb) {
+        var command = new GetRestApiCommand(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);
         }
-    }
-    getRestApis(args, optionsOrCb, cb) {
-        const command = new GetRestApisCommand(args);
+    };
+    APIGateway.prototype.getRestApis = function (args, optionsOrCb, cb) {
+        var command = new GetRestApisCommand(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);
         }
-    }
-    getSdk(args, optionsOrCb, cb) {
-        const command = new GetSdkCommand(args);
+    };
+    APIGateway.prototype.getSdk = function (args, optionsOrCb, cb) {
+        var command = new GetSdkCommand(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);
         }
-    }
-    getSdkType(args, optionsOrCb, cb) {
-        const command = new GetSdkTypeCommand(args);
+    };
+    APIGateway.prototype.getSdkType = function (args, optionsOrCb, cb) {
+        var command = new GetSdkTypeCommand(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);
         }
-    }
-    getSdkTypes(args, optionsOrCb, cb) {
-        const command = new GetSdkTypesCommand(args);
+    };
+    APIGateway.prototype.getSdkTypes = function (args, optionsOrCb, cb) {
+        var command = new GetSdkTypesCommand(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);
         }
-    }
-    getStage(args, optionsOrCb, cb) {
-        const command = new GetStageCommand(args);
+    };
+    APIGateway.prototype.getStage = function (args, optionsOrCb, cb) {
+        var command = new GetStageCommand(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);
         }
-    }
-    getStages(args, optionsOrCb, cb) {
-        const command = new GetStagesCommand(args);
+    };
+    APIGateway.prototype.getStages = function (args, optionsOrCb, cb) {
+        var command = new GetStagesCommand(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);
         }
-    }
-    getTags(args, optionsOrCb, cb) {
-        const command = new GetTagsCommand(args);
+    };
+    APIGateway.prototype.getTags = function (args, optionsOrCb, cb) {
+        var command = new GetTagsCommand(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);
         }
-    }
-    getUsage(args, optionsOrCb, cb) {
-        const command = new GetUsageCommand(args);
+    };
+    APIGateway.prototype.getUsage = function (args, optionsOrCb, cb) {
+        var command = new GetUsageCommand(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);
         }
-    }
-    getUsagePlan(args, optionsOrCb, cb) {
-        const command = new GetUsagePlanCommand(args);
+    };
+    APIGateway.prototype.getUsagePlan = function (args, optionsOrCb, cb) {
+        var command = new GetUsagePlanCommand(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);
         }
-    }
-    getUsagePlanKey(args, optionsOrCb, cb) {
-        const command = new GetUsagePlanKeyCommand(args);
+    };
+    APIGateway.prototype.getUsagePlanKey = function (args, optionsOrCb, cb) {
+        var command = new GetUsagePlanKeyCommand(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);
         }
-    }
-    getUsagePlanKeys(args, optionsOrCb, cb) {
-        const command = new GetUsagePlanKeysCommand(args);
+    };
+    APIGateway.prototype.getUsagePlanKeys = function (args, optionsOrCb, cb) {
+        var command = new GetUsagePlanKeysCommand(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);
         }
-    }
-    getUsagePlans(args, optionsOrCb, cb) {
-        const command = new GetUsagePlansCommand(args);
+    };
+    APIGateway.prototype.getUsagePlans = function (args, optionsOrCb, cb) {
+        var command = new GetUsagePlansCommand(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);
         }
-    }
-    getVpcLink(args, optionsOrCb, cb) {
-        const command = new GetVpcLinkCommand(args);
+    };
+    APIGateway.prototype.getVpcLink = function (args, optionsOrCb, cb) {
+        var command = new GetVpcLinkCommand(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);
         }
-    }
-    getVpcLinks(args, optionsOrCb, cb) {
-        const command = new GetVpcLinksCommand(args);
+    };
+    APIGateway.prototype.getVpcLinks = function (args, optionsOrCb, cb) {
+        var command = new GetVpcLinksCommand(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);
         }
-    }
-    importApiKeys(args, optionsOrCb, cb) {
-        const command = new ImportApiKeysCommand(args);
+    };
+    APIGateway.prototype.importApiKeys = function (args, optionsOrCb, cb) {
+        var command = new ImportApiKeysCommand(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);
         }
-    }
-    importDocumentationParts(args, optionsOrCb, cb) {
-        const command = new ImportDocumentationPartsCommand(args);
+    };
+    APIGateway.prototype.importDocumentationParts = function (args, optionsOrCb, cb) {
+        var command = new ImportDocumentationPartsCommand(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);
         }
-    }
-    importRestApi(args, optionsOrCb, cb) {
-        const command = new ImportRestApiCommand(args);
+    };
+    APIGateway.prototype.importRestApi = function (args, optionsOrCb, cb) {
+        var command = new ImportRestApiCommand(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);
         }
-    }
-    putGatewayResponse(args, optionsOrCb, cb) {
-        const command = new PutGatewayResponseCommand(args);
+    };
+    APIGateway.prototype.putGatewayResponse = function (args, optionsOrCb, cb) {
+        var command = new PutGatewayResponseCommand(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);
         }
-    }
-    putIntegration(args, optionsOrCb, cb) {
-        const command = new PutIntegrationCommand(args);
+    };
+    APIGateway.prototype.putIntegration = function (args, optionsOrCb, cb) {
+        var command = new PutIntegrationCommand(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);
         }
-    }
-    putIntegrationResponse(args, optionsOrCb, cb) {
-        const command = new PutIntegrationResponseCommand(args);
+    };
+    APIGateway.prototype.putIntegrationResponse = function (args, optionsOrCb, cb) {
+        var command = new PutIntegrationResponseCommand(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);
         }
-    }
-    putMethod(args, optionsOrCb, cb) {
-        const command = new PutMethodCommand(args);
+    };
+    APIGateway.prototype.putMethod = function (args, optionsOrCb, cb) {
+        var command = new PutMethodCommand(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);
         }
-    }
-    putMethodResponse(args, optionsOrCb, cb) {
-        const command = new PutMethodResponseCommand(args);
+    };
+    APIGateway.prototype.putMethodResponse = function (args, optionsOrCb, cb) {
+        var command = new PutMethodResponseCommand(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);
         }
-    }
-    putRestApi(args, optionsOrCb, cb) {
-        const command = new PutRestApiCommand(args);
+    };
+    APIGateway.prototype.putRestApi = function (args, optionsOrCb, cb) {
+        var command = new PutRestApiCommand(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);
+    };
+    APIGateway.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);
         }
-    }
-    testInvokeAuthorizer(args, optionsOrCb, cb) {
-        const command = new TestInvokeAuthorizerCommand(args);
+    };
+    APIGateway.prototype.testInvokeAuthorizer = function (args, optionsOrCb, cb) {
+        var command = new TestInvokeAuthorizerCommand(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);
         }
-    }
-    testInvokeMethod(args, optionsOrCb, cb) {
-        const command = new TestInvokeMethodCommand(args);
+    };
+    APIGateway.prototype.testInvokeMethod = function (args, optionsOrCb, cb) {
+        var command = new TestInvokeMethodCommand(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);
+    };
+    APIGateway.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);
         }
-    }
-    updateAccount(args, optionsOrCb, cb) {
-        const command = new UpdateAccountCommand(args);
+    };
+    APIGateway.prototype.updateAccount = function (args, optionsOrCb, cb) {
+        var command = new UpdateAccountCommand(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);
         }
-    }
-    updateApiKey(args, optionsOrCb, cb) {
-        const command = new UpdateApiKeyCommand(args);
+    };
+    APIGateway.prototype.updateApiKey = function (args, optionsOrCb, cb) {
+        var command = new UpdateApiKeyCommand(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);
         }
-    }
-    updateAuthorizer(args, optionsOrCb, cb) {
-        const command = new UpdateAuthorizerCommand(args);
+    };
+    APIGateway.prototype.updateAuthorizer = function (args, optionsOrCb, cb) {
+        var command = new UpdateAuthorizerCommand(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);
         }
-    }
-    updateBasePathMapping(args, optionsOrCb, cb) {
-        const command = new UpdateBasePathMappingCommand(args);
+    };
+    APIGateway.prototype.updateBasePathMapping = function (args, optionsOrCb, cb) {
+        var command = new UpdateBasePathMappingCommand(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);
         }
-    }
-    updateClientCertificate(args, optionsOrCb, cb) {
-        const command = new UpdateClientCertificateCommand(args);
+    };
+    APIGateway.prototype.updateClientCertificate = function (args, optionsOrCb, cb) {
+        var command = new UpdateClientCertificateCommand(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);
         }
-    }
-    updateDeployment(args, optionsOrCb, cb) {
-        const command = new UpdateDeploymentCommand(args);
+    };
+    APIGateway.prototype.updateDeployment = function (args, optionsOrCb, cb) {
+        var command = new UpdateDeploymentCommand(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);
         }
-    }
-    updateDocumentationPart(args, optionsOrCb, cb) {
-        const command = new UpdateDocumentationPartCommand(args);
+    };
+    APIGateway.prototype.updateDocumentationPart = function (args, optionsOrCb, cb) {
+        var command = new UpdateDocumentationPartCommand(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);
         }
-    }
-    updateDocumentationVersion(args, optionsOrCb, cb) {
-        const command = new UpdateDocumentationVersionCommand(args);
+    };
+    APIGateway.prototype.updateDocumentationVersion = function (args, optionsOrCb, cb) {
+        var command = new UpdateDocumentationVersionCommand(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);
         }
-    }
-    updateDomainName(args, optionsOrCb, cb) {
-        const command = new UpdateDomainNameCommand(args);
+    };
+    APIGateway.prototype.updateDomainName = function (args, optionsOrCb, cb) {
+        var command = new UpdateDomainNameCommand(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);
         }
-    }
-    updateGatewayResponse(args, optionsOrCb, cb) {
-        const command = new UpdateGatewayResponseCommand(args);
+    };
+    APIGateway.prototype.updateGatewayResponse = function (args, optionsOrCb, cb) {
+        var command = new UpdateGatewayResponseCommand(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);
         }
-    }
-    updateIntegration(args, optionsOrCb, cb) {
-        const command = new UpdateIntegrationCommand(args);
+    };
+    APIGateway.prototype.updateIntegration = function (args, optionsOrCb, cb) {
+        var command = new UpdateIntegrationCommand(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);
         }
-    }
-    updateIntegrationResponse(args, optionsOrCb, cb) {
-        const command = new UpdateIntegrationResponseCommand(args);
+    };
+    APIGateway.prototype.updateIntegrationResponse = function (args, optionsOrCb, cb) {
+        var command = new UpdateIntegrationResponseCommand(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);
         }
-    }
-    updateMethod(args, optionsOrCb, cb) {
-        const command = new UpdateMethodCommand(args);
+    };
+    APIGateway.prototype.updateMethod = function (args, optionsOrCb, cb) {
+        var command = new UpdateMethodCommand(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);
         }
-    }
-    updateMethodResponse(args, optionsOrCb, cb) {
-        const command = new UpdateMethodResponseCommand(args);
+    };
+    APIGateway.prototype.updateMethodResponse = function (args, optionsOrCb, cb) {
+        var command = new UpdateMethodResponseCommand(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);
         }
-    }
-    updateModel(args, optionsOrCb, cb) {
-        const command = new UpdateModelCommand(args);
+    };
+    APIGateway.prototype.updateModel = function (args, optionsOrCb, cb) {
+        var command = new UpdateModelCommand(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);
         }
-    }
-    updateRequestValidator(args, optionsOrCb, cb) {
-        const command = new UpdateRequestValidatorCommand(args);
+    };
+    APIGateway.prototype.updateRequestValidator = function (args, optionsOrCb, cb) {
+        var command = new UpdateRequestValidatorCommand(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);
         }
-    }
-    updateResource(args, optionsOrCb, cb) {
-        const command = new UpdateResourceCommand(args);
+    };
+    APIGateway.prototype.updateResource = function (args, optionsOrCb, cb) {
+        var command = new UpdateResourceCommand(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);
         }
-    }
-    updateRestApi(args, optionsOrCb, cb) {
-        const command = new UpdateRestApiCommand(args);
+    };
+    APIGateway.prototype.updateRestApi = function (args, optionsOrCb, cb) {
+        var command = new UpdateRestApiCommand(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);
         }
-    }
-    updateStage(args, optionsOrCb, cb) {
-        const command = new UpdateStageCommand(args);
+    };
+    APIGateway.prototype.updateStage = function (args, optionsOrCb, cb) {
+        var command = new UpdateStageCommand(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);
         }
-    }
-    updateUsage(args, optionsOrCb, cb) {
-        const command = new UpdateUsageCommand(args);
+    };
+    APIGateway.prototype.updateUsage = function (args, optionsOrCb, cb) {
+        var command = new UpdateUsageCommand(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);
         }
-    }
-    updateUsagePlan(args, optionsOrCb, cb) {
-        const command = new UpdateUsagePlanCommand(args);
+    };
+    APIGateway.prototype.updateUsagePlan = function (args, optionsOrCb, cb) {
+        var command = new UpdateUsagePlanCommand(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);
         }
-    }
-    updateVpcLink(args, optionsOrCb, cb) {
-        const command = new UpdateVpcLinkCommand(args);
+    };
+    APIGateway.prototype.updateVpcLink = function (args, optionsOrCb, cb) {
+        var command = new UpdateVpcLinkCommand(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 APIGateway;
+}(APIGatewayClient));
+export { APIGateway };