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

package/dist-es/commands/UpdateApiKeyCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ApiKeyFilterSensitiveLog, UpdateApiKeyRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateApiKeyCommand, serializeAws_restJson1UpdateApiKeyCommand, } from "../protocols/Aws_restJson1";
-export class UpdateApiKeyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateApiKeyCommand = (function (_super) {
+    __extends(UpdateApiKeyCommand, _super);
+    function UpdateApiKeyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateApiKeyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "APIGatewayClient";
-        const commandName = "UpdateApiKeyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateApiKeyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateApiKeyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ApiKeyFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateApiKeyCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateApiKeyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateApiKeyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateApiKeyCommand(output, context);
-    }
-}
+    };
+    return UpdateApiKeyCommand;
+}($Command));
+export { UpdateApiKeyCommand };

package/dist-es/commands/UpdateAuthorizerCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AuthorizerFilterSensitiveLog, UpdateAuthorizerRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateAuthorizerCommand, serializeAws_restJson1UpdateAuthorizerCommand, } from "../protocols/Aws_restJson1";
-export class UpdateAuthorizerCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateAuthorizerCommand = (function (_super) {
+    __extends(UpdateAuthorizerCommand, _super);
+    function UpdateAuthorizerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateAuthorizerCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "APIGatewayClient";
-        const commandName = "UpdateAuthorizerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateAuthorizerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateAuthorizerRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AuthorizerFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateAuthorizerCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateAuthorizerCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateAuthorizerCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateAuthorizerCommand(output, context);
-    }
-}
+    };
+    return UpdateAuthorizerCommand;
+}($Command));
+export { UpdateAuthorizerCommand };

package/dist-es/commands/UpdateBasePathMappingCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { BasePathMappingFilterSensitiveLog, UpdateBasePathMappingRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateBasePathMappingCommand, serializeAws_restJson1UpdateBasePathMappingCommand, } from "../protocols/Aws_restJson1";
-export class UpdateBasePathMappingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateBasePathMappingCommand = (function (_super) {
+    __extends(UpdateBasePathMappingCommand, _super);
+    function UpdateBasePathMappingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateBasePathMappingCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "APIGatewayClient";
-        const commandName = "UpdateBasePathMappingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateBasePathMappingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateBasePathMappingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: BasePathMappingFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateBasePathMappingCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateBasePathMappingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateBasePathMappingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateBasePathMappingCommand(output, context);
-    }
-}
+    };
+    return UpdateBasePathMappingCommand;
+}($Command));
+export { UpdateBasePathMappingCommand };

package/dist-es/commands/UpdateClientCertificateCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ClientCertificateFilterSensitiveLog, UpdateClientCertificateRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateClientCertificateCommand, serializeAws_restJson1UpdateClientCertificateCommand, } from "../protocols/Aws_restJson1";
-export class UpdateClientCertificateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateClientCertificateCommand = (function (_super) {
+    __extends(UpdateClientCertificateCommand, _super);
+    function UpdateClientCertificateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateClientCertificateCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "APIGatewayClient";
-        const commandName = "UpdateClientCertificateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateClientCertificateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateClientCertificateRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ClientCertificateFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateClientCertificateCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateClientCertificateCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateClientCertificateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateClientCertificateCommand(output, context);
-    }
-}
+    };
+    return UpdateClientCertificateCommand;
+}($Command));
+export { UpdateClientCertificateCommand };

package/dist-es/commands/UpdateDeploymentCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeploymentFilterSensitiveLog, UpdateDeploymentRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateDeploymentCommand, serializeAws_restJson1UpdateDeploymentCommand, } from "../protocols/Aws_restJson1";
-export class UpdateDeploymentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateDeploymentCommand = (function (_super) {
+    __extends(UpdateDeploymentCommand, _super);
+    function UpdateDeploymentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateDeploymentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "APIGatewayClient";
-        const commandName = "UpdateDeploymentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateDeploymentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateDeploymentRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeploymentFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateDeploymentCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateDeploymentCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateDeploymentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateDeploymentCommand(output, context);
-    }
-}
+    };
+    return UpdateDeploymentCommand;
+}($Command));
+export { UpdateDeploymentCommand };

package/dist-es/commands/UpdateDocumentationPartCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DocumentationPartFilterSensitiveLog, UpdateDocumentationPartRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateDocumentationPartCommand, serializeAws_restJson1UpdateDocumentationPartCommand, } from "../protocols/Aws_restJson1";
-export class UpdateDocumentationPartCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateDocumentationPartCommand = (function (_super) {
+    __extends(UpdateDocumentationPartCommand, _super);
+    function UpdateDocumentationPartCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateDocumentationPartCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "APIGatewayClient";
-        const commandName = "UpdateDocumentationPartCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateDocumentationPartCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateDocumentationPartRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DocumentationPartFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateDocumentationPartCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateDocumentationPartCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateDocumentationPartCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateDocumentationPartCommand(output, context);
-    }
-}
+    };
+    return UpdateDocumentationPartCommand;
+}($Command));
+export { UpdateDocumentationPartCommand };

package/dist-es/commands/UpdateDocumentationVersionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DocumentationVersionFilterSensitiveLog, UpdateDocumentationVersionRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateDocumentationVersionCommand, serializeAws_restJson1UpdateDocumentationVersionCommand, } from "../protocols/Aws_restJson1";
-export class UpdateDocumentationVersionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateDocumentationVersionCommand = (function (_super) {
+    __extends(UpdateDocumentationVersionCommand, _super);
+    function UpdateDocumentationVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateDocumentationVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "APIGatewayClient";
-        const commandName = "UpdateDocumentationVersionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateDocumentationVersionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateDocumentationVersionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DocumentationVersionFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateDocumentationVersionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateDocumentationVersionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateDocumentationVersionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateDocumentationVersionCommand(output, context);
-    }
-}
+    };
+    return UpdateDocumentationVersionCommand;
+}($Command));
+export { UpdateDocumentationVersionCommand };

package/dist-es/commands/UpdateDomainNameCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DomainNameFilterSensitiveLog, UpdateDomainNameRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateDomainNameCommand, serializeAws_restJson1UpdateDomainNameCommand, } from "../protocols/Aws_restJson1";
-export class UpdateDomainNameCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateDomainNameCommand = (function (_super) {
+    __extends(UpdateDomainNameCommand, _super);
+    function UpdateDomainNameCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateDomainNameCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "APIGatewayClient";
-        const commandName = "UpdateDomainNameCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateDomainNameCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateDomainNameRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DomainNameFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateDomainNameCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateDomainNameCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateDomainNameCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateDomainNameCommand(output, context);
-    }
-}
+    };
+    return UpdateDomainNameCommand;
+}($Command));
+export { UpdateDomainNameCommand };

package/dist-es/commands/UpdateGatewayResponseCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GatewayResponseFilterSensitiveLog, UpdateGatewayResponseRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateGatewayResponseCommand, serializeAws_restJson1UpdateGatewayResponseCommand, } from "../protocols/Aws_restJson1";
-export class UpdateGatewayResponseCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateGatewayResponseCommand = (function (_super) {
+    __extends(UpdateGatewayResponseCommand, _super);
+    function UpdateGatewayResponseCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateGatewayResponseCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "APIGatewayClient";
-        const commandName = "UpdateGatewayResponseCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateGatewayResponseCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateGatewayResponseRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GatewayResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateGatewayResponseCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateGatewayResponseCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateGatewayResponseCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateGatewayResponseCommand(output, context);
-    }
-}
+    };
+    return UpdateGatewayResponseCommand;
+}($Command));
+export { UpdateGatewayResponseCommand };

package/dist-es/commands/UpdateIntegrationCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { IntegrationFilterSensitiveLog, UpdateIntegrationRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateIntegrationCommand, serializeAws_restJson1UpdateIntegrationCommand, } from "../protocols/Aws_restJson1";
-export class UpdateIntegrationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateIntegrationCommand = (function (_super) {
+    __extends(UpdateIntegrationCommand, _super);
+    function UpdateIntegrationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateIntegrationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "APIGatewayClient";
-        const commandName = "UpdateIntegrationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateIntegrationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateIntegrationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: IntegrationFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateIntegrationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateIntegrationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateIntegrationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateIntegrationCommand(output, context);
-    }
-}
+    };
+    return UpdateIntegrationCommand;
+}($Command));
+export { UpdateIntegrationCommand };