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

package/dist-es/commands/UpdateIntegrationResponseCommand.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 { IntegrationResponseFilterSensitiveLog, UpdateIntegrationResponseRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateIntegrationResponseCommand, serializeAws_restJson1UpdateIntegrationResponseCommand, } from "../protocols/Aws_restJson1";
-export class UpdateIntegrationResponseCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateIntegrationResponseCommand = (function (_super) {
+    __extends(UpdateIntegrationResponseCommand, _super);
+    function UpdateIntegrationResponseCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateIntegrationResponseCommand.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 = "UpdateIntegrationResponseCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateIntegrationResponseCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateIntegrationResponseRequestFilterSensitiveLog,
             outputFilterSensitiveLog: IntegrationResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateIntegrationResponseCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateIntegrationResponseCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateIntegrationResponseCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateIntegrationResponseCommand(output, context);
-    }
-}
+    };
+    return UpdateIntegrationResponseCommand;
+}($Command));
+export { UpdateIntegrationResponseCommand };

package/dist-es/commands/UpdateMethodCommand.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 { MethodFilterSensitiveLog, UpdateMethodRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateMethodCommand, serializeAws_restJson1UpdateMethodCommand, } from "../protocols/Aws_restJson1";
-export class UpdateMethodCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateMethodCommand = (function (_super) {
+    __extends(UpdateMethodCommand, _super);
+    function UpdateMethodCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateMethodCommand.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 = "UpdateMethodCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateMethodCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateMethodRequestFilterSensitiveLog,
             outputFilterSensitiveLog: MethodFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateMethodCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateMethodCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateMethodCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateMethodCommand(output, context);
-    }
-}
+    };
+    return UpdateMethodCommand;
+}($Command));
+export { UpdateMethodCommand };

package/dist-es/commands/UpdateMethodResponseCommand.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 { MethodResponseFilterSensitiveLog, UpdateMethodResponseRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateMethodResponseCommand, serializeAws_restJson1UpdateMethodResponseCommand, } from "../protocols/Aws_restJson1";
-export class UpdateMethodResponseCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateMethodResponseCommand = (function (_super) {
+    __extends(UpdateMethodResponseCommand, _super);
+    function UpdateMethodResponseCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateMethodResponseCommand.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 = "UpdateMethodResponseCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateMethodResponseCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateMethodResponseRequestFilterSensitiveLog,
             outputFilterSensitiveLog: MethodResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateMethodResponseCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateMethodResponseCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateMethodResponseCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateMethodResponseCommand(output, context);
-    }
-}
+    };
+    return UpdateMethodResponseCommand;
+}($Command));
+export { UpdateMethodResponseCommand };

package/dist-es/commands/UpdateModelCommand.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 { ModelFilterSensitiveLog, UpdateModelRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateModelCommand, serializeAws_restJson1UpdateModelCommand, } from "../protocols/Aws_restJson1";
-export class UpdateModelCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateModelCommand = (function (_super) {
+    __extends(UpdateModelCommand, _super);
+    function UpdateModelCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateModelCommand.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 = "UpdateModelCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateModelCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateModelRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ModelFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateModelCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateModelCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateModelCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateModelCommand(output, context);
-    }
-}
+    };
+    return UpdateModelCommand;
+}($Command));
+export { UpdateModelCommand };

package/dist-es/commands/UpdateRequestValidatorCommand.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 { RequestValidatorFilterSensitiveLog, UpdateRequestValidatorRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateRequestValidatorCommand, serializeAws_restJson1UpdateRequestValidatorCommand, } from "../protocols/Aws_restJson1";
-export class UpdateRequestValidatorCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateRequestValidatorCommand = (function (_super) {
+    __extends(UpdateRequestValidatorCommand, _super);
+    function UpdateRequestValidatorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateRequestValidatorCommand.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 = "UpdateRequestValidatorCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateRequestValidatorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateRequestValidatorRequestFilterSensitiveLog,
             outputFilterSensitiveLog: RequestValidatorFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateRequestValidatorCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateRequestValidatorCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateRequestValidatorCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateRequestValidatorCommand(output, context);
-    }
-}
+    };
+    return UpdateRequestValidatorCommand;
+}($Command));
+export { UpdateRequestValidatorCommand };

package/dist-es/commands/UpdateResourceCommand.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 { ResourceFilterSensitiveLog, UpdateResourceRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateResourceCommand, serializeAws_restJson1UpdateResourceCommand, } from "../protocols/Aws_restJson1";
-export class UpdateResourceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateResourceCommand = (function (_super) {
+    __extends(UpdateResourceCommand, _super);
+    function UpdateResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateResourceCommand.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 = "UpdateResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateResourceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ResourceFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateResourceCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateResourceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateResourceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateResourceCommand(output, context);
-    }
-}
+    };
+    return UpdateResourceCommand;
+}($Command));
+export { UpdateResourceCommand };

package/dist-es/commands/UpdateRestApiCommand.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 { RestApiFilterSensitiveLog, UpdateRestApiRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateRestApiCommand, serializeAws_restJson1UpdateRestApiCommand, } from "../protocols/Aws_restJson1";
-export class UpdateRestApiCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateRestApiCommand = (function (_super) {
+    __extends(UpdateRestApiCommand, _super);
+    function UpdateRestApiCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateRestApiCommand.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 = "UpdateRestApiCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateRestApiCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateRestApiRequestFilterSensitiveLog,
             outputFilterSensitiveLog: RestApiFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateRestApiCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateRestApiCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateRestApiCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateRestApiCommand(output, context);
-    }
-}
+    };
+    return UpdateRestApiCommand;
+}($Command));
+export { UpdateRestApiCommand };

package/dist-es/commands/UpdateStageCommand.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 { StageFilterSensitiveLog, UpdateStageRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateStageCommand, serializeAws_restJson1UpdateStageCommand, } from "../protocols/Aws_restJson1";
-export class UpdateStageCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateStageCommand = (function (_super) {
+    __extends(UpdateStageCommand, _super);
+    function UpdateStageCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateStageCommand.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 = "UpdateStageCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateStageCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateStageRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StageFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateStageCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateStageCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateStageCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateStageCommand(output, context);
-    }
-}
+    };
+    return UpdateStageCommand;
+}($Command));
+export { UpdateStageCommand };

package/dist-es/commands/UpdateUsageCommand.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 { UpdateUsageRequestFilterSensitiveLog, UsageFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateUsageCommand, serializeAws_restJson1UpdateUsageCommand, } from "../protocols/Aws_restJson1";
-export class UpdateUsageCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateUsageCommand = (function (_super) {
+    __extends(UpdateUsageCommand, _super);
+    function UpdateUsageCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateUsageCommand.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 = "UpdateUsageCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateUsageCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateUsageRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UsageFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateUsageCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateUsageCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateUsageCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateUsageCommand(output, context);
-    }
-}
+    };
+    return UpdateUsageCommand;
+}($Command));
+export { UpdateUsageCommand };

package/dist-es/commands/UpdateUsagePlanCommand.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 { UpdateUsagePlanRequestFilterSensitiveLog, UsagePlanFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateUsagePlanCommand, serializeAws_restJson1UpdateUsagePlanCommand, } from "../protocols/Aws_restJson1";
-export class UpdateUsagePlanCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateUsagePlanCommand = (function (_super) {
+    __extends(UpdateUsagePlanCommand, _super);
+    function UpdateUsagePlanCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateUsagePlanCommand.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 = "UpdateUsagePlanCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "UpdateUsagePlanCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateUsagePlanRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UsagePlanFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateUsagePlanCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateUsagePlanCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateUsagePlanCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateUsagePlanCommand(output, context);
-    }
-}
+    };
+    return UpdateUsagePlanCommand;
+}($Command));
+export { UpdateUsagePlanCommand };