@aws-sdk/client-api-gateway 3.34.0 → 3.37.0

package/dist-es/commands/GetModelCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetModelRequest, Model } from "../models/models_0";
+import { deserializeAws_restJson1GetModelCommand, serializeAws_restJson1GetModelCommand, } from "../protocols/Aws_restJson1";
+var GetModelCommand = (function (_super) {
+    __extends(GetModelCommand, _super);
+    function GetModelCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetModelCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetModelCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetModelRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Model.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetModelCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetModelCommand(input, context);
+    };
+    GetModelCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetModelCommand(output, context);
+    };
+    return GetModelCommand;
+}($Command));
+export { GetModelCommand };

package/dist-es/commands/GetModelTemplateCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetModelTemplateRequest, Template } from "../models/models_0";
+import { deserializeAws_restJson1GetModelTemplateCommand, serializeAws_restJson1GetModelTemplateCommand, } from "../protocols/Aws_restJson1";
+var GetModelTemplateCommand = (function (_super) {
+    __extends(GetModelTemplateCommand, _super);
+    function GetModelTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetModelTemplateCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetModelTemplateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetModelTemplateRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Template.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetModelTemplateCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetModelTemplateCommand(input, context);
+    };
+    GetModelTemplateCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetModelTemplateCommand(output, context);
+    };
+    return GetModelTemplateCommand;
+}($Command));
+export { GetModelTemplateCommand };

package/dist-es/commands/GetModelsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetModelsRequest, Models } from "../models/models_0";
+import { deserializeAws_restJson1GetModelsCommand, serializeAws_restJson1GetModelsCommand, } from "../protocols/Aws_restJson1";
+var GetModelsCommand = (function (_super) {
+    __extends(GetModelsCommand, _super);
+    function GetModelsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetModelsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetModelsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetModelsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Models.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetModelsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetModelsCommand(input, context);
+    };
+    GetModelsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetModelsCommand(output, context);
+    };
+    return GetModelsCommand;
+}($Command));
+export { GetModelsCommand };

package/dist-es/commands/GetRequestValidatorCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetRequestValidatorRequest, RequestValidator } from "../models/models_0";
+import { deserializeAws_restJson1GetRequestValidatorCommand, serializeAws_restJson1GetRequestValidatorCommand, } from "../protocols/Aws_restJson1";
+var GetRequestValidatorCommand = (function (_super) {
+    __extends(GetRequestValidatorCommand, _super);
+    function GetRequestValidatorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetRequestValidatorCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetRequestValidatorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetRequestValidatorRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: RequestValidator.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRequestValidatorCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetRequestValidatorCommand(input, context);
+    };
+    GetRequestValidatorCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetRequestValidatorCommand(output, context);
+    };
+    return GetRequestValidatorCommand;
+}($Command));
+export { GetRequestValidatorCommand };

package/dist-es/commands/GetRequestValidatorsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetRequestValidatorsRequest, RequestValidators } from "../models/models_0";
+import { deserializeAws_restJson1GetRequestValidatorsCommand, serializeAws_restJson1GetRequestValidatorsCommand, } from "../protocols/Aws_restJson1";
+var GetRequestValidatorsCommand = (function (_super) {
+    __extends(GetRequestValidatorsCommand, _super);
+    function GetRequestValidatorsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetRequestValidatorsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetRequestValidatorsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetRequestValidatorsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: RequestValidators.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRequestValidatorsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetRequestValidatorsCommand(input, context);
+    };
+    GetRequestValidatorsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetRequestValidatorsCommand(output, context);
+    };
+    return GetRequestValidatorsCommand;
+}($Command));
+export { GetRequestValidatorsCommand };

package/dist-es/commands/GetResourceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetResourceRequest, Resource } from "../models/models_0";
+import { deserializeAws_restJson1GetResourceCommand, serializeAws_restJson1GetResourceCommand, } from "../protocols/Aws_restJson1";
+var GetResourceCommand = (function (_super) {
+    __extends(GetResourceCommand, _super);
+    function GetResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Resource.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetResourceCommand(input, context);
+    };
+    GetResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetResourceCommand(output, context);
+    };
+    return GetResourceCommand;
+}($Command));
+export { GetResourceCommand };

package/dist-es/commands/GetResourcesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetResourcesRequest, Resources } from "../models/models_0";
+import { deserializeAws_restJson1GetResourcesCommand, serializeAws_restJson1GetResourcesCommand, } from "../protocols/Aws_restJson1";
+var GetResourcesCommand = (function (_super) {
+    __extends(GetResourcesCommand, _super);
+    function GetResourcesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResourcesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetResourcesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResourcesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Resources.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResourcesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetResourcesCommand(input, context);
+    };
+    GetResourcesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetResourcesCommand(output, context);
+    };
+    return GetResourcesCommand;
+}($Command));
+export { GetResourcesCommand };

package/dist-es/commands/GetRestApiCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetRestApiRequest, RestApi } from "../models/models_0";
+import { deserializeAws_restJson1GetRestApiCommand, serializeAws_restJson1GetRestApiCommand, } from "../protocols/Aws_restJson1";
+var GetRestApiCommand = (function (_super) {
+    __extends(GetRestApiCommand, _super);
+    function GetRestApiCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetRestApiCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetRestApiCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetRestApiRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: RestApi.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRestApiCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetRestApiCommand(input, context);
+    };
+    GetRestApiCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetRestApiCommand(output, context);
+    };
+    return GetRestApiCommand;
+}($Command));
+export { GetRestApiCommand };

package/dist-es/commands/GetRestApisCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetRestApisRequest, RestApis } from "../models/models_0";
+import { deserializeAws_restJson1GetRestApisCommand, serializeAws_restJson1GetRestApisCommand, } from "../protocols/Aws_restJson1";
+var GetRestApisCommand = (function (_super) {
+    __extends(GetRestApisCommand, _super);
+    function GetRestApisCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetRestApisCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetRestApisCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetRestApisRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: RestApis.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRestApisCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetRestApisCommand(input, context);
+    };
+    GetRestApisCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetRestApisCommand(output, context);
+    };
+    return GetRestApisCommand;
+}($Command));
+export { GetRestApisCommand };

package/dist-es/commands/GetSdkCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSdkRequest, SdkResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetSdkCommand, serializeAws_restJson1GetSdkCommand } from "../protocols/Aws_restJson1";
+var GetSdkCommand = (function (_super) {
+    __extends(GetSdkCommand, _super);
+    function GetSdkCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetSdkCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetSdkCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetSdkRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SdkResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetSdkCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetSdkCommand(input, context);
+    };
+    GetSdkCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetSdkCommand(output, context);
+    };
+    return GetSdkCommand;
+}($Command));
+export { GetSdkCommand };

package/dist-es/commands/GetSdkTypeCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSdkTypeRequest, SdkType } from "../models/models_0";
+import { deserializeAws_restJson1GetSdkTypeCommand, serializeAws_restJson1GetSdkTypeCommand, } from "../protocols/Aws_restJson1";
+var GetSdkTypeCommand = (function (_super) {
+    __extends(GetSdkTypeCommand, _super);
+    function GetSdkTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetSdkTypeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetSdkTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetSdkTypeRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SdkType.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetSdkTypeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetSdkTypeCommand(input, context);
+    };
+    GetSdkTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetSdkTypeCommand(output, context);
+    };
+    return GetSdkTypeCommand;
+}($Command));
+export { GetSdkTypeCommand };

package/dist-es/commands/GetSdkTypesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSdkTypesRequest, SdkTypes } from "../models/models_0";
+import { deserializeAws_restJson1GetSdkTypesCommand, serializeAws_restJson1GetSdkTypesCommand, } from "../protocols/Aws_restJson1";
+var GetSdkTypesCommand = (function (_super) {
+    __extends(GetSdkTypesCommand, _super);
+    function GetSdkTypesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetSdkTypesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetSdkTypesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetSdkTypesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SdkTypes.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetSdkTypesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetSdkTypesCommand(input, context);
+    };
+    GetSdkTypesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetSdkTypesCommand(output, context);
+    };
+    return GetSdkTypesCommand;
+}($Command));
+export { GetSdkTypesCommand };

package/dist-es/commands/GetStageCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetStageRequest, Stage } from "../models/models_0";
+import { deserializeAws_restJson1GetStageCommand, serializeAws_restJson1GetStageCommand, } from "../protocols/Aws_restJson1";
+var GetStageCommand = (function (_super) {
+    __extends(GetStageCommand, _super);
+    function GetStageCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetStageCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetStageCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetStageRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Stage.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetStageCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetStageCommand(input, context);
+    };
+    GetStageCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetStageCommand(output, context);
+    };
+    return GetStageCommand;
+}($Command));
+export { GetStageCommand };

package/dist-es/commands/GetStagesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetStagesRequest, Stages } from "../models/models_0";
+import { deserializeAws_restJson1GetStagesCommand, serializeAws_restJson1GetStagesCommand, } from "../protocols/Aws_restJson1";
+var GetStagesCommand = (function (_super) {
+    __extends(GetStagesCommand, _super);
+    function GetStagesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetStagesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetStagesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetStagesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Stages.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetStagesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetStagesCommand(input, context);
+    };
+    GetStagesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetStagesCommand(output, context);
+    };
+    return GetStagesCommand;
+}($Command));
+export { GetStagesCommand };

package/dist-es/commands/GetTagsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetTagsRequest, Tags } from "../models/models_0";
+import { deserializeAws_restJson1GetTagsCommand, serializeAws_restJson1GetTagsCommand, } from "../protocols/Aws_restJson1";
+var GetTagsCommand = (function (_super) {
+    __extends(GetTagsCommand, _super);
+    function GetTagsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetTagsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetTagsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetTagsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Tags.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetTagsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetTagsCommand(input, context);
+    };
+    GetTagsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetTagsCommand(output, context);
+    };
+    return GetTagsCommand;
+}($Command));
+export { GetTagsCommand };

package/dist-es/commands/GetUsageCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetUsageRequest, Usage } from "../models/models_0";
+import { deserializeAws_restJson1GetUsageCommand, serializeAws_restJson1GetUsageCommand, } from "../protocols/Aws_restJson1";
+var GetUsageCommand = (function (_super) {
+    __extends(GetUsageCommand, _super);
+    function GetUsageCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetUsageCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetUsageCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetUsageRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Usage.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetUsageCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetUsageCommand(input, context);
+    };
+    GetUsageCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetUsageCommand(output, context);
+    };
+    return GetUsageCommand;
+}($Command));
+export { GetUsageCommand };