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

package/dist-es/APIGateway.js

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