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

package/dist-es/commands/GetUsagePlanCommand.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 { GetUsagePlanRequest, UsagePlan } from "../models/models_0";
+import { deserializeAws_restJson1GetUsagePlanCommand, serializeAws_restJson1GetUsagePlanCommand, } from "../protocols/Aws_restJson1";
+var GetUsagePlanCommand = (function (_super) {
+    __extends(GetUsagePlanCommand, _super);
+    function GetUsagePlanCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetUsagePlanCommand.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 = "GetUsagePlanCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetUsagePlanRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UsagePlan.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetUsagePlanCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetUsagePlanCommand(input, context);
+    };
+    GetUsagePlanCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetUsagePlanCommand(output, context);
+    };
+    return GetUsagePlanCommand;
+}($Command));
+export { GetUsagePlanCommand };

package/dist-es/commands/GetUsagePlanKeyCommand.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 { GetUsagePlanKeyRequest, UsagePlanKey } from "../models/models_0";
+import { deserializeAws_restJson1GetUsagePlanKeyCommand, serializeAws_restJson1GetUsagePlanKeyCommand, } from "../protocols/Aws_restJson1";
+var GetUsagePlanKeyCommand = (function (_super) {
+    __extends(GetUsagePlanKeyCommand, _super);
+    function GetUsagePlanKeyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetUsagePlanKeyCommand.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 = "GetUsagePlanKeyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetUsagePlanKeyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UsagePlanKey.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetUsagePlanKeyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetUsagePlanKeyCommand(input, context);
+    };
+    GetUsagePlanKeyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetUsagePlanKeyCommand(output, context);
+    };
+    return GetUsagePlanKeyCommand;
+}($Command));
+export { GetUsagePlanKeyCommand };

package/dist-es/commands/GetUsagePlanKeysCommand.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 { GetUsagePlanKeysRequest, UsagePlanKeys } from "../models/models_0";
+import { deserializeAws_restJson1GetUsagePlanKeysCommand, serializeAws_restJson1GetUsagePlanKeysCommand, } from "../protocols/Aws_restJson1";
+var GetUsagePlanKeysCommand = (function (_super) {
+    __extends(GetUsagePlanKeysCommand, _super);
+    function GetUsagePlanKeysCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetUsagePlanKeysCommand.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 = "GetUsagePlanKeysCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetUsagePlanKeysRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UsagePlanKeys.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetUsagePlanKeysCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetUsagePlanKeysCommand(input, context);
+    };
+    GetUsagePlanKeysCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetUsagePlanKeysCommand(output, context);
+    };
+    return GetUsagePlanKeysCommand;
+}($Command));
+export { GetUsagePlanKeysCommand };

package/dist-es/commands/GetUsagePlansCommand.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 { GetUsagePlansRequest, UsagePlans } from "../models/models_0";
+import { deserializeAws_restJson1GetUsagePlansCommand, serializeAws_restJson1GetUsagePlansCommand, } from "../protocols/Aws_restJson1";
+var GetUsagePlansCommand = (function (_super) {
+    __extends(GetUsagePlansCommand, _super);
+    function GetUsagePlansCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetUsagePlansCommand.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 = "GetUsagePlansCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetUsagePlansRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UsagePlans.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetUsagePlansCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetUsagePlansCommand(input, context);
+    };
+    GetUsagePlansCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetUsagePlansCommand(output, context);
+    };
+    return GetUsagePlansCommand;
+}($Command));
+export { GetUsagePlansCommand };

package/dist-es/commands/GetVpcLinkCommand.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 { GetVpcLinkRequest, VpcLink } from "../models/models_0";
+import { deserializeAws_restJson1GetVpcLinkCommand, serializeAws_restJson1GetVpcLinkCommand, } from "../protocols/Aws_restJson1";
+var GetVpcLinkCommand = (function (_super) {
+    __extends(GetVpcLinkCommand, _super);
+    function GetVpcLinkCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetVpcLinkCommand.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 = "GetVpcLinkCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetVpcLinkRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: VpcLink.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetVpcLinkCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetVpcLinkCommand(input, context);
+    };
+    GetVpcLinkCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetVpcLinkCommand(output, context);
+    };
+    return GetVpcLinkCommand;
+}($Command));
+export { GetVpcLinkCommand };

package/dist-es/commands/GetVpcLinksCommand.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 { GetVpcLinksRequest, VpcLinks } from "../models/models_0";
+import { deserializeAws_restJson1GetVpcLinksCommand, serializeAws_restJson1GetVpcLinksCommand, } from "../protocols/Aws_restJson1";
+var GetVpcLinksCommand = (function (_super) {
+    __extends(GetVpcLinksCommand, _super);
+    function GetVpcLinksCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetVpcLinksCommand.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 = "GetVpcLinksCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetVpcLinksRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: VpcLinks.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetVpcLinksCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetVpcLinksCommand(input, context);
+    };
+    GetVpcLinksCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetVpcLinksCommand(output, context);
+    };
+    return GetVpcLinksCommand;
+}($Command));
+export { GetVpcLinksCommand };

package/dist-es/commands/ImportApiKeysCommand.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 { ApiKeyIds, ImportApiKeysRequest } from "../models/models_0";
+import { deserializeAws_restJson1ImportApiKeysCommand, serializeAws_restJson1ImportApiKeysCommand, } from "../protocols/Aws_restJson1";
+var ImportApiKeysCommand = (function (_super) {
+    __extends(ImportApiKeysCommand, _super);
+    function ImportApiKeysCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ImportApiKeysCommand.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 = "ImportApiKeysCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ImportApiKeysRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ApiKeyIds.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ImportApiKeysCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ImportApiKeysCommand(input, context);
+    };
+    ImportApiKeysCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ImportApiKeysCommand(output, context);
+    };
+    return ImportApiKeysCommand;
+}($Command));
+export { ImportApiKeysCommand };

package/dist-es/commands/ImportDocumentationPartsCommand.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 { DocumentationPartIds, ImportDocumentationPartsRequest } from "../models/models_0";
+import { deserializeAws_restJson1ImportDocumentationPartsCommand, serializeAws_restJson1ImportDocumentationPartsCommand, } from "../protocols/Aws_restJson1";
+var ImportDocumentationPartsCommand = (function (_super) {
+    __extends(ImportDocumentationPartsCommand, _super);
+    function ImportDocumentationPartsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ImportDocumentationPartsCommand.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 = "ImportDocumentationPartsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ImportDocumentationPartsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DocumentationPartIds.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ImportDocumentationPartsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ImportDocumentationPartsCommand(input, context);
+    };
+    ImportDocumentationPartsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ImportDocumentationPartsCommand(output, context);
+    };
+    return ImportDocumentationPartsCommand;
+}($Command));
+export { ImportDocumentationPartsCommand };

package/dist-es/commands/ImportRestApiCommand.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 { ImportRestApiRequest, RestApi } from "../models/models_0";
+import { deserializeAws_restJson1ImportRestApiCommand, serializeAws_restJson1ImportRestApiCommand, } from "../protocols/Aws_restJson1";
+var ImportRestApiCommand = (function (_super) {
+    __extends(ImportRestApiCommand, _super);
+    function ImportRestApiCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ImportRestApiCommand.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 = "ImportRestApiCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ImportRestApiRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: RestApi.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ImportRestApiCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ImportRestApiCommand(input, context);
+    };
+    ImportRestApiCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ImportRestApiCommand(output, context);
+    };
+    return ImportRestApiCommand;
+}($Command));
+export { ImportRestApiCommand };

package/dist-es/commands/PutGatewayResponseCommand.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 { GatewayResponse, PutGatewayResponseRequest } from "../models/models_0";
+import { deserializeAws_restJson1PutGatewayResponseCommand, serializeAws_restJson1PutGatewayResponseCommand, } from "../protocols/Aws_restJson1";
+var PutGatewayResponseCommand = (function (_super) {
+    __extends(PutGatewayResponseCommand, _super);
+    function PutGatewayResponseCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutGatewayResponseCommand.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 = "PutGatewayResponseCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutGatewayResponseRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GatewayResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutGatewayResponseCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1PutGatewayResponseCommand(input, context);
+    };
+    PutGatewayResponseCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PutGatewayResponseCommand(output, context);
+    };
+    return PutGatewayResponseCommand;
+}($Command));
+export { PutGatewayResponseCommand };

package/dist-es/commands/PutIntegrationCommand.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 { Integration, PutIntegrationRequest } from "../models/models_0";
+import { deserializeAws_restJson1PutIntegrationCommand, serializeAws_restJson1PutIntegrationCommand, } from "../protocols/Aws_restJson1";
+var PutIntegrationCommand = (function (_super) {
+    __extends(PutIntegrationCommand, _super);
+    function PutIntegrationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutIntegrationCommand.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 = "PutIntegrationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutIntegrationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Integration.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutIntegrationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1PutIntegrationCommand(input, context);
+    };
+    PutIntegrationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PutIntegrationCommand(output, context);
+    };
+    return PutIntegrationCommand;
+}($Command));
+export { PutIntegrationCommand };

package/dist-es/commands/PutIntegrationResponseCommand.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 { IntegrationResponse, PutIntegrationResponseRequest } from "../models/models_0";
+import { deserializeAws_restJson1PutIntegrationResponseCommand, serializeAws_restJson1PutIntegrationResponseCommand, } from "../protocols/Aws_restJson1";
+var PutIntegrationResponseCommand = (function (_super) {
+    __extends(PutIntegrationResponseCommand, _super);
+    function PutIntegrationResponseCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutIntegrationResponseCommand.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 = "PutIntegrationResponseCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutIntegrationResponseRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: IntegrationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutIntegrationResponseCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1PutIntegrationResponseCommand(input, context);
+    };
+    PutIntegrationResponseCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PutIntegrationResponseCommand(output, context);
+    };
+    return PutIntegrationResponseCommand;
+}($Command));
+export { PutIntegrationResponseCommand };

package/dist-es/commands/PutMethodCommand.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 { Method, PutMethodRequest } from "../models/models_0";
+import { deserializeAws_restJson1PutMethodCommand, serializeAws_restJson1PutMethodCommand, } from "../protocols/Aws_restJson1";
+var PutMethodCommand = (function (_super) {
+    __extends(PutMethodCommand, _super);
+    function PutMethodCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutMethodCommand.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 = "PutMethodCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutMethodRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Method.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutMethodCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1PutMethodCommand(input, context);
+    };
+    PutMethodCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PutMethodCommand(output, context);
+    };
+    return PutMethodCommand;
+}($Command));
+export { PutMethodCommand };

package/dist-es/commands/PutMethodResponseCommand.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 { MethodResponse, PutMethodResponseRequest } from "../models/models_0";
+import { deserializeAws_restJson1PutMethodResponseCommand, serializeAws_restJson1PutMethodResponseCommand, } from "../protocols/Aws_restJson1";
+var PutMethodResponseCommand = (function (_super) {
+    __extends(PutMethodResponseCommand, _super);
+    function PutMethodResponseCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutMethodResponseCommand.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 = "PutMethodResponseCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutMethodResponseRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: MethodResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutMethodResponseCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1PutMethodResponseCommand(input, context);
+    };
+    PutMethodResponseCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PutMethodResponseCommand(output, context);
+    };
+    return PutMethodResponseCommand;
+}($Command));
+export { PutMethodResponseCommand };

package/dist-es/commands/PutRestApiCommand.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 { PutRestApiRequest, RestApi } from "../models/models_0";
+import { deserializeAws_restJson1PutRestApiCommand, serializeAws_restJson1PutRestApiCommand, } from "../protocols/Aws_restJson1";
+var PutRestApiCommand = (function (_super) {
+    __extends(PutRestApiCommand, _super);
+    function PutRestApiCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutRestApiCommand.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 = "PutRestApiCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutRestApiRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: RestApi.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutRestApiCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1PutRestApiCommand(input, context);
+    };
+    PutRestApiCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PutRestApiCommand(output, context);
+    };
+    return PutRestApiCommand;
+}($Command));
+export { PutRestApiCommand };

package/dist-es/commands/TagResourceCommand.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 { TagResourceRequest } from "../models/models_0";
+import { deserializeAws_restJson1TagResourceCommand, serializeAws_restJson1TagResourceCommand, } from "../protocols/Aws_restJson1";
+var TagResourceCommand = (function (_super) {
+    __extends(TagResourceCommand, _super);
+    function TagResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    TagResourceCommand.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 = "TagResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: TagResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    TagResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1TagResourceCommand(input, context);
+    };
+    TagResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1TagResourceCommand(output, context);
+    };
+    return TagResourceCommand;
+}($Command));
+export { TagResourceCommand };