APIGatewayClient.h

 
#pragma once
#include <aws/apigateway/APIGateway_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/apigateway/APIGatewayServiceClientModel.h>
 
namespace Aws
{
namespace APIGateway
{
  class AWS_APIGATEWAY_API APIGatewayClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<APIGatewayClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef APIGatewayClientConfiguration ClientConfigurationType;
      typedef APIGatewayEndpointProvider EndpointProviderType;
 
        APIGatewayClient(const Aws::APIGateway::APIGatewayClientConfiguration& clientConfiguration = Aws::APIGateway::APIGatewayClientConfiguration(),
                         std::shared_ptr<APIGatewayEndpointProviderBase> endpointProvider = nullptr);
 
        APIGatewayClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<APIGatewayEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::APIGateway::APIGatewayClientConfiguration& clientConfiguration = Aws::APIGateway::APIGatewayClientConfiguration());
 
        APIGatewayClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<APIGatewayEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::APIGateway::APIGatewayClientConfiguration& clientConfiguration = Aws::APIGateway::APIGatewayClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        APIGatewayClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        APIGatewayClient(const Aws::Auth::AWSCredentials& credentials,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        APIGatewayClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~APIGatewayClient();
 
        virtual Model::CreateApiKeyOutcome CreateApiKey(const Model::CreateApiKeyRequest& request = {}) const;
 
        template<typename CreateApiKeyRequestT = Model::CreateApiKeyRequest>
        Model::CreateApiKeyOutcomeCallable CreateApiKeyCallable(const CreateApiKeyRequestT& request = {}) const
        {
            return SubmitCallable(&APIGatewayClient::CreateApiKey, request);
        }
 
        template<typename CreateApiKeyRequestT = Model::CreateApiKeyRequest>
        void CreateApiKeyAsync(const CreateApiKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateApiKeyRequestT& request = {}) const
        {
            return SubmitAsync(&APIGatewayClient::CreateApiKey, request, handler, context);
        }
 
        virtual Model::CreateAuthorizerOutcome CreateAuthorizer(const Model::CreateAuthorizerRequest& request) const;
 
        template<typename CreateAuthorizerRequestT = Model::CreateAuthorizerRequest>
        Model::CreateAuthorizerOutcomeCallable CreateAuthorizerCallable(const CreateAuthorizerRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateAuthorizer, request);
        }
 
        template<typename CreateAuthorizerRequestT = Model::CreateAuthorizerRequest>
        void CreateAuthorizerAsync(const CreateAuthorizerRequestT& request, const CreateAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateAuthorizer, request, handler, context);
        }
 
        virtual Model::CreateBasePathMappingOutcome CreateBasePathMapping(const Model::CreateBasePathMappingRequest& request) const;
 
        template<typename CreateBasePathMappingRequestT = Model::CreateBasePathMappingRequest>
        Model::CreateBasePathMappingOutcomeCallable CreateBasePathMappingCallable(const CreateBasePathMappingRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateBasePathMapping, request);
        }
 
        template<typename CreateBasePathMappingRequestT = Model::CreateBasePathMappingRequest>
        void CreateBasePathMappingAsync(const CreateBasePathMappingRequestT& request, const CreateBasePathMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateBasePathMapping, request, handler, context);
        }
 
        virtual Model::CreateDeploymentOutcome CreateDeployment(const Model::CreateDeploymentRequest& request) const;
 
        template<typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
        Model::CreateDeploymentOutcomeCallable CreateDeploymentCallable(const CreateDeploymentRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateDeployment, request);
        }
 
        template<typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
        void CreateDeploymentAsync(const CreateDeploymentRequestT& request, const CreateDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateDeployment, request, handler, context);
        }
 
        virtual Model::CreateDocumentationPartOutcome CreateDocumentationPart(const Model::CreateDocumentationPartRequest& request) const;
 
        template<typename CreateDocumentationPartRequestT = Model::CreateDocumentationPartRequest>
        Model::CreateDocumentationPartOutcomeCallable CreateDocumentationPartCallable(const CreateDocumentationPartRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateDocumentationPart, request);
        }
 
        template<typename CreateDocumentationPartRequestT = Model::CreateDocumentationPartRequest>
        void CreateDocumentationPartAsync(const CreateDocumentationPartRequestT& request, const CreateDocumentationPartResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateDocumentationPart, request, handler, context);
        }
 
        virtual Model::CreateDocumentationVersionOutcome CreateDocumentationVersion(const Model::CreateDocumentationVersionRequest& request) const;
 
        template<typename CreateDocumentationVersionRequestT = Model::CreateDocumentationVersionRequest>
        Model::CreateDocumentationVersionOutcomeCallable CreateDocumentationVersionCallable(const CreateDocumentationVersionRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateDocumentationVersion, request);
        }
 
        template<typename CreateDocumentationVersionRequestT = Model::CreateDocumentationVersionRequest>
        void CreateDocumentationVersionAsync(const CreateDocumentationVersionRequestT& request, const CreateDocumentationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateDocumentationVersion, request, handler, context);
        }
 
        virtual Model::CreateDomainNameOutcome CreateDomainName(const Model::CreateDomainNameRequest& request) const;
 
        template<typename CreateDomainNameRequestT = Model::CreateDomainNameRequest>
        Model::CreateDomainNameOutcomeCallable CreateDomainNameCallable(const CreateDomainNameRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateDomainName, request);
        }
 
        template<typename CreateDomainNameRequestT = Model::CreateDomainNameRequest>
        void CreateDomainNameAsync(const CreateDomainNameRequestT& request, const CreateDomainNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateDomainName, request, handler, context);
        }
 
        virtual Model::CreateModelOutcome CreateModel(const Model::CreateModelRequest& request) const;
 
        template<typename CreateModelRequestT = Model::CreateModelRequest>
        Model::CreateModelOutcomeCallable CreateModelCallable(const CreateModelRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateModel, request);
        }
 
        template<typename CreateModelRequestT = Model::CreateModelRequest>
        void CreateModelAsync(const CreateModelRequestT& request, const CreateModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateModel, request, handler, context);
        }
 
        virtual Model::CreateRequestValidatorOutcome CreateRequestValidator(const Model::CreateRequestValidatorRequest& request) const;
 
        template<typename CreateRequestValidatorRequestT = Model::CreateRequestValidatorRequest>
        Model::CreateRequestValidatorOutcomeCallable CreateRequestValidatorCallable(const CreateRequestValidatorRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateRequestValidator, request);
        }
 
        template<typename CreateRequestValidatorRequestT = Model::CreateRequestValidatorRequest>
        void CreateRequestValidatorAsync(const CreateRequestValidatorRequestT& request, const CreateRequestValidatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateRequestValidator, request, handler, context);
        }
 
        virtual Model::CreateResourceOutcome CreateResource(const Model::CreateResourceRequest& request) const;
 
        template<typename CreateResourceRequestT = Model::CreateResourceRequest>
        Model::CreateResourceOutcomeCallable CreateResourceCallable(const CreateResourceRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateResource, request);
        }
 
        template<typename CreateResourceRequestT = Model::CreateResourceRequest>
        void CreateResourceAsync(const CreateResourceRequestT& request, const CreateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateResource, request, handler, context);
        }
 
        virtual Model::CreateRestApiOutcome CreateRestApi(const Model::CreateRestApiRequest& request) const;
 
        template<typename CreateRestApiRequestT = Model::CreateRestApiRequest>
        Model::CreateRestApiOutcomeCallable CreateRestApiCallable(const CreateRestApiRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateRestApi, request);
        }
 
        template<typename CreateRestApiRequestT = Model::CreateRestApiRequest>
        void CreateRestApiAsync(const CreateRestApiRequestT& request, const CreateRestApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateRestApi, request, handler, context);
        }
 
        virtual Model::CreateStageOutcome CreateStage(const Model::CreateStageRequest& request) const;
 
        template<typename CreateStageRequestT = Model::CreateStageRequest>
        Model::CreateStageOutcomeCallable CreateStageCallable(const CreateStageRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateStage, request);
        }
 
        template<typename CreateStageRequestT = Model::CreateStageRequest>
        void CreateStageAsync(const CreateStageRequestT& request, const CreateStageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateStage, request, handler, context);
        }
 
        virtual Model::CreateUsagePlanOutcome CreateUsagePlan(const Model::CreateUsagePlanRequest& request) const;
 
        template<typename CreateUsagePlanRequestT = Model::CreateUsagePlanRequest>
        Model::CreateUsagePlanOutcomeCallable CreateUsagePlanCallable(const CreateUsagePlanRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateUsagePlan, request);
        }
 
        template<typename CreateUsagePlanRequestT = Model::CreateUsagePlanRequest>
        void CreateUsagePlanAsync(const CreateUsagePlanRequestT& request, const CreateUsagePlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateUsagePlan, request, handler, context);
        }
 
        virtual Model::CreateUsagePlanKeyOutcome CreateUsagePlanKey(const Model::CreateUsagePlanKeyRequest& request) const;
 
        template<typename CreateUsagePlanKeyRequestT = Model::CreateUsagePlanKeyRequest>
        Model::CreateUsagePlanKeyOutcomeCallable CreateUsagePlanKeyCallable(const CreateUsagePlanKeyRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateUsagePlanKey, request);
        }
 
        template<typename CreateUsagePlanKeyRequestT = Model::CreateUsagePlanKeyRequest>
        void CreateUsagePlanKeyAsync(const CreateUsagePlanKeyRequestT& request, const CreateUsagePlanKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateUsagePlanKey, request, handler, context);
        }
 
        virtual Model::CreateVpcLinkOutcome CreateVpcLink(const Model::CreateVpcLinkRequest& request) const;
 
        template<typename CreateVpcLinkRequestT = Model::CreateVpcLinkRequest>
        Model::CreateVpcLinkOutcomeCallable CreateVpcLinkCallable(const CreateVpcLinkRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::CreateVpcLink, request);
        }
 
        template<typename CreateVpcLinkRequestT = Model::CreateVpcLinkRequest>
        void CreateVpcLinkAsync(const CreateVpcLinkRequestT& request, const CreateVpcLinkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::CreateVpcLink, request, handler, context);
        }
 
        virtual Model::DeleteApiKeyOutcome DeleteApiKey(const Model::DeleteApiKeyRequest& request) const;
 
        template<typename DeleteApiKeyRequestT = Model::DeleteApiKeyRequest>
        Model::DeleteApiKeyOutcomeCallable DeleteApiKeyCallable(const DeleteApiKeyRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteApiKey, request);
        }
 
        template<typename DeleteApiKeyRequestT = Model::DeleteApiKeyRequest>
        void DeleteApiKeyAsync(const DeleteApiKeyRequestT& request, const DeleteApiKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteApiKey, request, handler, context);
        }
 
        virtual Model::DeleteAuthorizerOutcome DeleteAuthorizer(const Model::DeleteAuthorizerRequest& request) const;
 
        template<typename DeleteAuthorizerRequestT = Model::DeleteAuthorizerRequest>
        Model::DeleteAuthorizerOutcomeCallable DeleteAuthorizerCallable(const DeleteAuthorizerRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteAuthorizer, request);
        }
 
        template<typename DeleteAuthorizerRequestT = Model::DeleteAuthorizerRequest>
        void DeleteAuthorizerAsync(const DeleteAuthorizerRequestT& request, const DeleteAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteAuthorizer, request, handler, context);
        }
 
        virtual Model::DeleteBasePathMappingOutcome DeleteBasePathMapping(const Model::DeleteBasePathMappingRequest& request) const;
 
        template<typename DeleteBasePathMappingRequestT = Model::DeleteBasePathMappingRequest>
        Model::DeleteBasePathMappingOutcomeCallable DeleteBasePathMappingCallable(const DeleteBasePathMappingRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteBasePathMapping, request);
        }
 
        template<typename DeleteBasePathMappingRequestT = Model::DeleteBasePathMappingRequest>
        void DeleteBasePathMappingAsync(const DeleteBasePathMappingRequestT& request, const DeleteBasePathMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteBasePathMapping, request, handler, context);
        }
 
        virtual Model::DeleteClientCertificateOutcome DeleteClientCertificate(const Model::DeleteClientCertificateRequest& request) const;
 
        template<typename DeleteClientCertificateRequestT = Model::DeleteClientCertificateRequest>
        Model::DeleteClientCertificateOutcomeCallable DeleteClientCertificateCallable(const DeleteClientCertificateRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteClientCertificate, request);
        }
 
        template<typename DeleteClientCertificateRequestT = Model::DeleteClientCertificateRequest>
        void DeleteClientCertificateAsync(const DeleteClientCertificateRequestT& request, const DeleteClientCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteClientCertificate, request, handler, context);
        }
 
        virtual Model::DeleteDeploymentOutcome DeleteDeployment(const Model::DeleteDeploymentRequest& request) const;
 
        template<typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
        Model::DeleteDeploymentOutcomeCallable DeleteDeploymentCallable(const DeleteDeploymentRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteDeployment, request);
        }
 
        template<typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
        void DeleteDeploymentAsync(const DeleteDeploymentRequestT& request, const DeleteDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteDeployment, request, handler, context);
        }
 
        virtual Model::DeleteDocumentationPartOutcome DeleteDocumentationPart(const Model::DeleteDocumentationPartRequest& request) const;
 
        template<typename DeleteDocumentationPartRequestT = Model::DeleteDocumentationPartRequest>
        Model::DeleteDocumentationPartOutcomeCallable DeleteDocumentationPartCallable(const DeleteDocumentationPartRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteDocumentationPart, request);
        }
 
        template<typename DeleteDocumentationPartRequestT = Model::DeleteDocumentationPartRequest>
        void DeleteDocumentationPartAsync(const DeleteDocumentationPartRequestT& request, const DeleteDocumentationPartResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteDocumentationPart, request, handler, context);
        }
 
        virtual Model::DeleteDocumentationVersionOutcome DeleteDocumentationVersion(const Model::DeleteDocumentationVersionRequest& request) const;
 
        template<typename DeleteDocumentationVersionRequestT = Model::DeleteDocumentationVersionRequest>
        Model::DeleteDocumentationVersionOutcomeCallable DeleteDocumentationVersionCallable(const DeleteDocumentationVersionRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteDocumentationVersion, request);
        }
 
        template<typename DeleteDocumentationVersionRequestT = Model::DeleteDocumentationVersionRequest>
        void DeleteDocumentationVersionAsync(const DeleteDocumentationVersionRequestT& request, const DeleteDocumentationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteDocumentationVersion, request, handler, context);
        }
 
        virtual Model::DeleteDomainNameOutcome DeleteDomainName(const Model::DeleteDomainNameRequest& request) const;
 
        template<typename DeleteDomainNameRequestT = Model::DeleteDomainNameRequest>
        Model::DeleteDomainNameOutcomeCallable DeleteDomainNameCallable(const DeleteDomainNameRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteDomainName, request);
        }
 
        template<typename DeleteDomainNameRequestT = Model::DeleteDomainNameRequest>
        void DeleteDomainNameAsync(const DeleteDomainNameRequestT& request, const DeleteDomainNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteDomainName, request, handler, context);
        }
 
        virtual Model::DeleteGatewayResponseOutcome DeleteGatewayResponse(const Model::DeleteGatewayResponseRequest& request) const;
 
        template<typename DeleteGatewayResponseRequestT = Model::DeleteGatewayResponseRequest>
        Model::DeleteGatewayResponseOutcomeCallable DeleteGatewayResponseCallable(const DeleteGatewayResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteGatewayResponse, request);
        }
 
        template<typename DeleteGatewayResponseRequestT = Model::DeleteGatewayResponseRequest>
        void DeleteGatewayResponseAsync(const DeleteGatewayResponseRequestT& request, const DeleteGatewayResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteGatewayResponse, request, handler, context);
        }
 
        virtual Model::DeleteIntegrationOutcome DeleteIntegration(const Model::DeleteIntegrationRequest& request) const;
 
        template<typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
        Model::DeleteIntegrationOutcomeCallable DeleteIntegrationCallable(const DeleteIntegrationRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteIntegration, request);
        }
 
        template<typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
        void DeleteIntegrationAsync(const DeleteIntegrationRequestT& request, const DeleteIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteIntegration, request, handler, context);
        }
 
        virtual Model::DeleteIntegrationResponseOutcome DeleteIntegrationResponse(const Model::DeleteIntegrationResponseRequest& request) const;
 
        template<typename DeleteIntegrationResponseRequestT = Model::DeleteIntegrationResponseRequest>
        Model::DeleteIntegrationResponseOutcomeCallable DeleteIntegrationResponseCallable(const DeleteIntegrationResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteIntegrationResponse, request);
        }
 
        template<typename DeleteIntegrationResponseRequestT = Model::DeleteIntegrationResponseRequest>
        void DeleteIntegrationResponseAsync(const DeleteIntegrationResponseRequestT& request, const DeleteIntegrationResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteIntegrationResponse, request, handler, context);
        }
 
        virtual Model::DeleteMethodOutcome DeleteMethod(const Model::DeleteMethodRequest& request) const;
 
        template<typename DeleteMethodRequestT = Model::DeleteMethodRequest>
        Model::DeleteMethodOutcomeCallable DeleteMethodCallable(const DeleteMethodRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteMethod, request);
        }
 
        template<typename DeleteMethodRequestT = Model::DeleteMethodRequest>
        void DeleteMethodAsync(const DeleteMethodRequestT& request, const DeleteMethodResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteMethod, request, handler, context);
        }
 
        virtual Model::DeleteMethodResponseOutcome DeleteMethodResponse(const Model::DeleteMethodResponseRequest& request) const;
 
        template<typename DeleteMethodResponseRequestT = Model::DeleteMethodResponseRequest>
        Model::DeleteMethodResponseOutcomeCallable DeleteMethodResponseCallable(const DeleteMethodResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteMethodResponse, request);
        }
 
        template<typename DeleteMethodResponseRequestT = Model::DeleteMethodResponseRequest>
        void DeleteMethodResponseAsync(const DeleteMethodResponseRequestT& request, const DeleteMethodResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteMethodResponse, request, handler, context);
        }
 
        virtual Model::DeleteModelOutcome DeleteModel(const Model::DeleteModelRequest& request) const;
 
        template<typename DeleteModelRequestT = Model::DeleteModelRequest>
        Model::DeleteModelOutcomeCallable DeleteModelCallable(const DeleteModelRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteModel, request);
        }
 
        template<typename DeleteModelRequestT = Model::DeleteModelRequest>
        void DeleteModelAsync(const DeleteModelRequestT& request, const DeleteModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteModel, request, handler, context);
        }
 
        virtual Model::DeleteRequestValidatorOutcome DeleteRequestValidator(const Model::DeleteRequestValidatorRequest& request) const;
 
        template<typename DeleteRequestValidatorRequestT = Model::DeleteRequestValidatorRequest>
        Model::DeleteRequestValidatorOutcomeCallable DeleteRequestValidatorCallable(const DeleteRequestValidatorRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteRequestValidator, request);
        }
 
        template<typename DeleteRequestValidatorRequestT = Model::DeleteRequestValidatorRequest>
        void DeleteRequestValidatorAsync(const DeleteRequestValidatorRequestT& request, const DeleteRequestValidatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteRequestValidator, request, handler, context);
        }
 
        virtual Model::DeleteResourceOutcome DeleteResource(const Model::DeleteResourceRequest& request) const;
 
        template<typename DeleteResourceRequestT = Model::DeleteResourceRequest>
        Model::DeleteResourceOutcomeCallable DeleteResourceCallable(const DeleteResourceRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteResource, request);
        }
 
        template<typename DeleteResourceRequestT = Model::DeleteResourceRequest>
        void DeleteResourceAsync(const DeleteResourceRequestT& request, const DeleteResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteResource, request, handler, context);
        }
 
        virtual Model::DeleteRestApiOutcome DeleteRestApi(const Model::DeleteRestApiRequest& request) const;
 
        template<typename DeleteRestApiRequestT = Model::DeleteRestApiRequest>
        Model::DeleteRestApiOutcomeCallable DeleteRestApiCallable(const DeleteRestApiRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteRestApi, request);
        }
 
        template<typename DeleteRestApiRequestT = Model::DeleteRestApiRequest>
        void DeleteRestApiAsync(const DeleteRestApiRequestT& request, const DeleteRestApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteRestApi, request, handler, context);
        }
 
        virtual Model::DeleteStageOutcome DeleteStage(const Model::DeleteStageRequest& request) const;
 
        template<typename DeleteStageRequestT = Model::DeleteStageRequest>
        Model::DeleteStageOutcomeCallable DeleteStageCallable(const DeleteStageRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteStage, request);
        }
 
        template<typename DeleteStageRequestT = Model::DeleteStageRequest>
        void DeleteStageAsync(const DeleteStageRequestT& request, const DeleteStageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteStage, request, handler, context);
        }
 
        virtual Model::DeleteUsagePlanOutcome DeleteUsagePlan(const Model::DeleteUsagePlanRequest& request) const;
 
        template<typename DeleteUsagePlanRequestT = Model::DeleteUsagePlanRequest>
        Model::DeleteUsagePlanOutcomeCallable DeleteUsagePlanCallable(const DeleteUsagePlanRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteUsagePlan, request);
        }
 
        template<typename DeleteUsagePlanRequestT = Model::DeleteUsagePlanRequest>
        void DeleteUsagePlanAsync(const DeleteUsagePlanRequestT& request, const DeleteUsagePlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteUsagePlan, request, handler, context);
        }
 
        virtual Model::DeleteUsagePlanKeyOutcome DeleteUsagePlanKey(const Model::DeleteUsagePlanKeyRequest& request) const;
 
        template<typename DeleteUsagePlanKeyRequestT = Model::DeleteUsagePlanKeyRequest>
        Model::DeleteUsagePlanKeyOutcomeCallable DeleteUsagePlanKeyCallable(const DeleteUsagePlanKeyRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteUsagePlanKey, request);
        }
 
        template<typename DeleteUsagePlanKeyRequestT = Model::DeleteUsagePlanKeyRequest>
        void DeleteUsagePlanKeyAsync(const DeleteUsagePlanKeyRequestT& request, const DeleteUsagePlanKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteUsagePlanKey, request, handler, context);
        }
 
        virtual Model::DeleteVpcLinkOutcome DeleteVpcLink(const Model::DeleteVpcLinkRequest& request) const;
 
        template<typename DeleteVpcLinkRequestT = Model::DeleteVpcLinkRequest>
        Model::DeleteVpcLinkOutcomeCallable DeleteVpcLinkCallable(const DeleteVpcLinkRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::DeleteVpcLink, request);
        }
 
        template<typename DeleteVpcLinkRequestT = Model::DeleteVpcLinkRequest>
        void DeleteVpcLinkAsync(const DeleteVpcLinkRequestT& request, const DeleteVpcLinkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::DeleteVpcLink, request, handler, context);
        }
 
        virtual Model::FlushStageAuthorizersCacheOutcome FlushStageAuthorizersCache(const Model::FlushStageAuthorizersCacheRequest& request) const;
 
        template<typename FlushStageAuthorizersCacheRequestT = Model::FlushStageAuthorizersCacheRequest>
        Model::FlushStageAuthorizersCacheOutcomeCallable FlushStageAuthorizersCacheCallable(const FlushStageAuthorizersCacheRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::FlushStageAuthorizersCache, request);
        }
 
        template<typename FlushStageAuthorizersCacheRequestT = Model::FlushStageAuthorizersCacheRequest>
        void FlushStageAuthorizersCacheAsync(const FlushStageAuthorizersCacheRequestT& request, const FlushStageAuthorizersCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::FlushStageAuthorizersCache, request, handler, context);
        }
 
        virtual Model::FlushStageCacheOutcome FlushStageCache(const Model::FlushStageCacheRequest& request) const;
 
        template<typename FlushStageCacheRequestT = Model::FlushStageCacheRequest>
        Model::FlushStageCacheOutcomeCallable FlushStageCacheCallable(const FlushStageCacheRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::FlushStageCache, request);
        }
 
        template<typename FlushStageCacheRequestT = Model::FlushStageCacheRequest>
        void FlushStageCacheAsync(const FlushStageCacheRequestT& request, const FlushStageCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::FlushStageCache, request, handler, context);
        }
 
        virtual Model::GenerateClientCertificateOutcome GenerateClientCertificate(const Model::GenerateClientCertificateRequest& request = {}) const;
 
        template<typename GenerateClientCertificateRequestT = Model::GenerateClientCertificateRequest>
        Model::GenerateClientCertificateOutcomeCallable GenerateClientCertificateCallable(const GenerateClientCertificateRequestT& request = {}) const
        {
            return SubmitCallable(&APIGatewayClient::GenerateClientCertificate, request);
        }
 
        template<typename GenerateClientCertificateRequestT = Model::GenerateClientCertificateRequest>
        void GenerateClientCertificateAsync(const GenerateClientCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GenerateClientCertificateRequestT& request = {}) const
        {
            return SubmitAsync(&APIGatewayClient::GenerateClientCertificate, request, handler, context);
        }
 
        virtual Model::GetAccountOutcome GetAccount(const Model::GetAccountRequest& request = {}) const;
 
        template<typename GetAccountRequestT = Model::GetAccountRequest>
        Model::GetAccountOutcomeCallable GetAccountCallable(const GetAccountRequestT& request = {}) const
        {
            return SubmitCallable(&APIGatewayClient::GetAccount, request);
        }
 
        template<typename GetAccountRequestT = Model::GetAccountRequest>
        void GetAccountAsync(const GetAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountRequestT& request = {}) const
        {
            return SubmitAsync(&APIGatewayClient::GetAccount, request, handler, context);
        }
 
        virtual Model::GetApiKeyOutcome GetApiKey(const Model::GetApiKeyRequest& request) const;
 
        template<typename GetApiKeyRequestT = Model::GetApiKeyRequest>
        Model::GetApiKeyOutcomeCallable GetApiKeyCallable(const GetApiKeyRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetApiKey, request);
        }
 
        template<typename GetApiKeyRequestT = Model::GetApiKeyRequest>
        void GetApiKeyAsync(const GetApiKeyRequestT& request, const GetApiKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetApiKey, request, handler, context);
        }
 
        virtual Model::GetApiKeysOutcome GetApiKeys(const Model::GetApiKeysRequest& request = {}) const;
 
        template<typename GetApiKeysRequestT = Model::GetApiKeysRequest>
        Model::GetApiKeysOutcomeCallable GetApiKeysCallable(const GetApiKeysRequestT& request = {}) const
        {
            return SubmitCallable(&APIGatewayClient::GetApiKeys, request);
        }
 
        template<typename GetApiKeysRequestT = Model::GetApiKeysRequest>
        void GetApiKeysAsync(const GetApiKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetApiKeysRequestT& request = {}) const
        {
            return SubmitAsync(&APIGatewayClient::GetApiKeys, request, handler, context);
        }
 
        virtual Model::GetAuthorizerOutcome GetAuthorizer(const Model::GetAuthorizerRequest& request) const;
 
        template<typename GetAuthorizerRequestT = Model::GetAuthorizerRequest>
        Model::GetAuthorizerOutcomeCallable GetAuthorizerCallable(const GetAuthorizerRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetAuthorizer, request);
        }
 
        template<typename GetAuthorizerRequestT = Model::GetAuthorizerRequest>
        void GetAuthorizerAsync(const GetAuthorizerRequestT& request, const GetAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetAuthorizer, request, handler, context);
        }
 
        virtual Model::GetAuthorizersOutcome GetAuthorizers(const Model::GetAuthorizersRequest& request) const;
 
        template<typename GetAuthorizersRequestT = Model::GetAuthorizersRequest>
        Model::GetAuthorizersOutcomeCallable GetAuthorizersCallable(const GetAuthorizersRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetAuthorizers, request);
        }
 
        template<typename GetAuthorizersRequestT = Model::GetAuthorizersRequest>
        void GetAuthorizersAsync(const GetAuthorizersRequestT& request, const GetAuthorizersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetAuthorizers, request, handler, context);
        }
 
        virtual Model::GetBasePathMappingOutcome GetBasePathMapping(const Model::GetBasePathMappingRequest& request) const;
 
        template<typename GetBasePathMappingRequestT = Model::GetBasePathMappingRequest>
        Model::GetBasePathMappingOutcomeCallable GetBasePathMappingCallable(const GetBasePathMappingRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetBasePathMapping, request);
        }
 
        template<typename GetBasePathMappingRequestT = Model::GetBasePathMappingRequest>
        void GetBasePathMappingAsync(const GetBasePathMappingRequestT& request, const GetBasePathMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetBasePathMapping, request, handler, context);
        }
 
        virtual Model::GetBasePathMappingsOutcome GetBasePathMappings(const Model::GetBasePathMappingsRequest& request) const;
 
        template<typename GetBasePathMappingsRequestT = Model::GetBasePathMappingsRequest>
        Model::GetBasePathMappingsOutcomeCallable GetBasePathMappingsCallable(const GetBasePathMappingsRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetBasePathMappings, request);
        }
 
        template<typename GetBasePathMappingsRequestT = Model::GetBasePathMappingsRequest>
        void GetBasePathMappingsAsync(const GetBasePathMappingsRequestT& request, const GetBasePathMappingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetBasePathMappings, request, handler, context);
        }
 
        virtual Model::GetClientCertificateOutcome GetClientCertificate(const Model::GetClientCertificateRequest& request) const;
 
        template<typename GetClientCertificateRequestT = Model::GetClientCertificateRequest>
        Model::GetClientCertificateOutcomeCallable GetClientCertificateCallable(const GetClientCertificateRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetClientCertificate, request);
        }
 
        template<typename GetClientCertificateRequestT = Model::GetClientCertificateRequest>
        void GetClientCertificateAsync(const GetClientCertificateRequestT& request, const GetClientCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetClientCertificate, request, handler, context);
        }
 
        virtual Model::GetClientCertificatesOutcome GetClientCertificates(const Model::GetClientCertificatesRequest& request = {}) const;
 
        template<typename GetClientCertificatesRequestT = Model::GetClientCertificatesRequest>
        Model::GetClientCertificatesOutcomeCallable GetClientCertificatesCallable(const GetClientCertificatesRequestT& request = {}) const
        {
            return SubmitCallable(&APIGatewayClient::GetClientCertificates, request);
        }
 
        template<typename GetClientCertificatesRequestT = Model::GetClientCertificatesRequest>
        void GetClientCertificatesAsync(const GetClientCertificatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetClientCertificatesRequestT& request = {}) const
        {
            return SubmitAsync(&APIGatewayClient::GetClientCertificates, request, handler, context);
        }
 
        virtual Model::GetDeploymentOutcome GetDeployment(const Model::GetDeploymentRequest& request) const;
 
        template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
        Model::GetDeploymentOutcomeCallable GetDeploymentCallable(const GetDeploymentRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetDeployment, request);
        }
 
        template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
        void GetDeploymentAsync(const GetDeploymentRequestT& request, const GetDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetDeployment, request, handler, context);
        }
 
        virtual Model::GetDeploymentsOutcome GetDeployments(const Model::GetDeploymentsRequest& request) const;
 
        template<typename GetDeploymentsRequestT = Model::GetDeploymentsRequest>
        Model::GetDeploymentsOutcomeCallable GetDeploymentsCallable(const GetDeploymentsRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetDeployments, request);
        }
 
        template<typename GetDeploymentsRequestT = Model::GetDeploymentsRequest>
        void GetDeploymentsAsync(const GetDeploymentsRequestT& request, const GetDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetDeployments, request, handler, context);
        }
 
        virtual Model::GetDocumentationPartOutcome GetDocumentationPart(const Model::GetDocumentationPartRequest& request) const;
 
        template<typename GetDocumentationPartRequestT = Model::GetDocumentationPartRequest>
        Model::GetDocumentationPartOutcomeCallable GetDocumentationPartCallable(const GetDocumentationPartRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetDocumentationPart, request);
        }
 
        template<typename GetDocumentationPartRequestT = Model::GetDocumentationPartRequest>
        void GetDocumentationPartAsync(const GetDocumentationPartRequestT& request, const GetDocumentationPartResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetDocumentationPart, request, handler, context);
        }
 
        virtual Model::GetDocumentationPartsOutcome GetDocumentationParts(const Model::GetDocumentationPartsRequest& request) const;
 
        template<typename GetDocumentationPartsRequestT = Model::GetDocumentationPartsRequest>
        Model::GetDocumentationPartsOutcomeCallable GetDocumentationPartsCallable(const GetDocumentationPartsRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetDocumentationParts, request);
        }
 
        template<typename GetDocumentationPartsRequestT = Model::GetDocumentationPartsRequest>
        void GetDocumentationPartsAsync(const GetDocumentationPartsRequestT& request, const GetDocumentationPartsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetDocumentationParts, request, handler, context);
        }
 
        virtual Model::GetDocumentationVersionOutcome GetDocumentationVersion(const Model::GetDocumentationVersionRequest& request) const;
 
        template<typename GetDocumentationVersionRequestT = Model::GetDocumentationVersionRequest>
        Model::GetDocumentationVersionOutcomeCallable GetDocumentationVersionCallable(const GetDocumentationVersionRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetDocumentationVersion, request);
        }
 
        template<typename GetDocumentationVersionRequestT = Model::GetDocumentationVersionRequest>
        void GetDocumentationVersionAsync(const GetDocumentationVersionRequestT& request, const GetDocumentationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetDocumentationVersion, request, handler, context);
        }
 
        virtual Model::GetDocumentationVersionsOutcome GetDocumentationVersions(const Model::GetDocumentationVersionsRequest& request) const;
 
        template<typename GetDocumentationVersionsRequestT = Model::GetDocumentationVersionsRequest>
        Model::GetDocumentationVersionsOutcomeCallable GetDocumentationVersionsCallable(const GetDocumentationVersionsRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetDocumentationVersions, request);
        }
 
        template<typename GetDocumentationVersionsRequestT = Model::GetDocumentationVersionsRequest>
        void GetDocumentationVersionsAsync(const GetDocumentationVersionsRequestT& request, const GetDocumentationVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetDocumentationVersions, request, handler, context);
        }
 
        virtual Model::GetDomainNameOutcome GetDomainName(const Model::GetDomainNameRequest& request) const;
 
        template<typename GetDomainNameRequestT = Model::GetDomainNameRequest>
        Model::GetDomainNameOutcomeCallable GetDomainNameCallable(const GetDomainNameRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetDomainName, request);
        }
 
        template<typename GetDomainNameRequestT = Model::GetDomainNameRequest>
        void GetDomainNameAsync(const GetDomainNameRequestT& request, const GetDomainNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetDomainName, request, handler, context);
        }
 
        virtual Model::GetDomainNamesOutcome GetDomainNames(const Model::GetDomainNamesRequest& request = {}) const;
 
        template<typename GetDomainNamesRequestT = Model::GetDomainNamesRequest>
        Model::GetDomainNamesOutcomeCallable GetDomainNamesCallable(const GetDomainNamesRequestT& request = {}) const
        {
            return SubmitCallable(&APIGatewayClient::GetDomainNames, request);
        }
 
        template<typename GetDomainNamesRequestT = Model::GetDomainNamesRequest>
        void GetDomainNamesAsync(const GetDomainNamesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDomainNamesRequestT& request = {}) const
        {
            return SubmitAsync(&APIGatewayClient::GetDomainNames, request, handler, context);
        }
 
        virtual Model::GetExportOutcome GetExport(const Model::GetExportRequest& request) const;
 
        template<typename GetExportRequestT = Model::GetExportRequest>
        Model::GetExportOutcomeCallable GetExportCallable(const GetExportRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetExport, request);
        }
 
        template<typename GetExportRequestT = Model::GetExportRequest>
        void GetExportAsync(const GetExportRequestT& request, const GetExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetExport, request, handler, context);
        }
 
        virtual Model::GetGatewayResponseOutcome GetGatewayResponse(const Model::GetGatewayResponseRequest& request) const;
 
        template<typename GetGatewayResponseRequestT = Model::GetGatewayResponseRequest>
        Model::GetGatewayResponseOutcomeCallable GetGatewayResponseCallable(const GetGatewayResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetGatewayResponse, request);
        }
 
        template<typename GetGatewayResponseRequestT = Model::GetGatewayResponseRequest>
        void GetGatewayResponseAsync(const GetGatewayResponseRequestT& request, const GetGatewayResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetGatewayResponse, request, handler, context);
        }
 
        virtual Model::GetGatewayResponsesOutcome GetGatewayResponses(const Model::GetGatewayResponsesRequest& request) const;
 
        template<typename GetGatewayResponsesRequestT = Model::GetGatewayResponsesRequest>
        Model::GetGatewayResponsesOutcomeCallable GetGatewayResponsesCallable(const GetGatewayResponsesRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetGatewayResponses, request);
        }
 
        template<typename GetGatewayResponsesRequestT = Model::GetGatewayResponsesRequest>
        void GetGatewayResponsesAsync(const GetGatewayResponsesRequestT& request, const GetGatewayResponsesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetGatewayResponses, request, handler, context);
        }
 
        virtual Model::GetIntegrationOutcome GetIntegration(const Model::GetIntegrationRequest& request) const;
 
        template<typename GetIntegrationRequestT = Model::GetIntegrationRequest>
        Model::GetIntegrationOutcomeCallable GetIntegrationCallable(const GetIntegrationRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetIntegration, request);
        }
 
        template<typename GetIntegrationRequestT = Model::GetIntegrationRequest>
        void GetIntegrationAsync(const GetIntegrationRequestT& request, const GetIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetIntegration, request, handler, context);
        }
 
        virtual Model::GetIntegrationResponseOutcome GetIntegrationResponse(const Model::GetIntegrationResponseRequest& request) const;
 
        template<typename GetIntegrationResponseRequestT = Model::GetIntegrationResponseRequest>
        Model::GetIntegrationResponseOutcomeCallable GetIntegrationResponseCallable(const GetIntegrationResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetIntegrationResponse, request);
        }
 
        template<typename GetIntegrationResponseRequestT = Model::GetIntegrationResponseRequest>
        void GetIntegrationResponseAsync(const GetIntegrationResponseRequestT& request, const GetIntegrationResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetIntegrationResponse, request, handler, context);
        }
 
        virtual Model::GetMethodOutcome GetMethod(const Model::GetMethodRequest& request) const;
 
        template<typename GetMethodRequestT = Model::GetMethodRequest>
        Model::GetMethodOutcomeCallable GetMethodCallable(const GetMethodRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetMethod, request);
        }
 
        template<typename GetMethodRequestT = Model::GetMethodRequest>
        void GetMethodAsync(const GetMethodRequestT& request, const GetMethodResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetMethod, request, handler, context);
        }
 
        virtual Model::GetMethodResponseOutcome GetMethodResponse(const Model::GetMethodResponseRequest& request) const;
 
        template<typename GetMethodResponseRequestT = Model::GetMethodResponseRequest>
        Model::GetMethodResponseOutcomeCallable GetMethodResponseCallable(const GetMethodResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetMethodResponse, request);
        }
 
        template<typename GetMethodResponseRequestT = Model::GetMethodResponseRequest>
        void GetMethodResponseAsync(const GetMethodResponseRequestT& request, const GetMethodResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetMethodResponse, request, handler, context);
        }
 
        virtual Model::GetModelOutcome GetModel(const Model::GetModelRequest& request) const;
 
        template<typename GetModelRequestT = Model::GetModelRequest>
        Model::GetModelOutcomeCallable GetModelCallable(const GetModelRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetModel, request);
        }
 
        template<typename GetModelRequestT = Model::GetModelRequest>
        void GetModelAsync(const GetModelRequestT& request, const GetModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetModel, request, handler, context);
        }
 
        virtual Model::GetModelTemplateOutcome GetModelTemplate(const Model::GetModelTemplateRequest& request) const;
 
        template<typename GetModelTemplateRequestT = Model::GetModelTemplateRequest>
        Model::GetModelTemplateOutcomeCallable GetModelTemplateCallable(const GetModelTemplateRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetModelTemplate, request);
        }
 
        template<typename GetModelTemplateRequestT = Model::GetModelTemplateRequest>
        void GetModelTemplateAsync(const GetModelTemplateRequestT& request, const GetModelTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetModelTemplate, request, handler, context);
        }
 
        virtual Model::GetModelsOutcome GetModels(const Model::GetModelsRequest& request) const;
 
        template<typename GetModelsRequestT = Model::GetModelsRequest>
        Model::GetModelsOutcomeCallable GetModelsCallable(const GetModelsRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetModels, request);
        }
 
        template<typename GetModelsRequestT = Model::GetModelsRequest>
        void GetModelsAsync(const GetModelsRequestT& request, const GetModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetModels, request, handler, context);
        }
 
        virtual Model::GetRequestValidatorOutcome GetRequestValidator(const Model::GetRequestValidatorRequest& request) const;
 
        template<typename GetRequestValidatorRequestT = Model::GetRequestValidatorRequest>
        Model::GetRequestValidatorOutcomeCallable GetRequestValidatorCallable(const GetRequestValidatorRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetRequestValidator, request);
        }
 
        template<typename GetRequestValidatorRequestT = Model::GetRequestValidatorRequest>
        void GetRequestValidatorAsync(const GetRequestValidatorRequestT& request, const GetRequestValidatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetRequestValidator, request, handler, context);
        }
 
        virtual Model::GetRequestValidatorsOutcome GetRequestValidators(const Model::GetRequestValidatorsRequest& request) const;
 
        template<typename GetRequestValidatorsRequestT = Model::GetRequestValidatorsRequest>
        Model::GetRequestValidatorsOutcomeCallable GetRequestValidatorsCallable(const GetRequestValidatorsRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetRequestValidators, request);
        }
 
        template<typename GetRequestValidatorsRequestT = Model::GetRequestValidatorsRequest>
        void GetRequestValidatorsAsync(const GetRequestValidatorsRequestT& request, const GetRequestValidatorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetRequestValidators, request, handler, context);
        }
 
        virtual Model::GetResourceOutcome GetResource(const Model::GetResourceRequest& request) const;
 
        template<typename GetResourceRequestT = Model::GetResourceRequest>
        Model::GetResourceOutcomeCallable GetResourceCallable(const GetResourceRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetResource, request);
        }
 
        template<typename GetResourceRequestT = Model::GetResourceRequest>
        void GetResourceAsync(const GetResourceRequestT& request, const GetResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetResource, request, handler, context);
        }
 
        virtual Model::GetResourcesOutcome GetResources(const Model::GetResourcesRequest& request) const;
 
        template<typename GetResourcesRequestT = Model::GetResourcesRequest>
        Model::GetResourcesOutcomeCallable GetResourcesCallable(const GetResourcesRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetResources, request);
        }
 
        template<typename GetResourcesRequestT = Model::GetResourcesRequest>
        void GetResourcesAsync(const GetResourcesRequestT& request, const GetResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetResources, request, handler, context);
        }
 
        virtual Model::GetRestApiOutcome GetRestApi(const Model::GetRestApiRequest& request) const;
 
        template<typename GetRestApiRequestT = Model::GetRestApiRequest>
        Model::GetRestApiOutcomeCallable GetRestApiCallable(const GetRestApiRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetRestApi, request);
        }
 
        template<typename GetRestApiRequestT = Model::GetRestApiRequest>
        void GetRestApiAsync(const GetRestApiRequestT& request, const GetRestApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetRestApi, request, handler, context);
        }
 
        virtual Model::GetRestApisOutcome GetRestApis(const Model::GetRestApisRequest& request = {}) const;
 
        template<typename GetRestApisRequestT = Model::GetRestApisRequest>
        Model::GetRestApisOutcomeCallable GetRestApisCallable(const GetRestApisRequestT& request = {}) const
        {
            return SubmitCallable(&APIGatewayClient::GetRestApis, request);
        }
 
        template<typename GetRestApisRequestT = Model::GetRestApisRequest>
        void GetRestApisAsync(const GetRestApisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetRestApisRequestT& request = {}) const
        {
            return SubmitAsync(&APIGatewayClient::GetRestApis, request, handler, context);
        }
 
        virtual Model::GetSdkOutcome GetSdk(const Model::GetSdkRequest& request) const;
 
        template<typename GetSdkRequestT = Model::GetSdkRequest>
        Model::GetSdkOutcomeCallable GetSdkCallable(const GetSdkRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetSdk, request);
        }
 
        template<typename GetSdkRequestT = Model::GetSdkRequest>
        void GetSdkAsync(const GetSdkRequestT& request, const GetSdkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetSdk, request, handler, context);
        }
 
        virtual Model::GetSdkTypeOutcome GetSdkType(const Model::GetSdkTypeRequest& request) const;
 
        template<typename GetSdkTypeRequestT = Model::GetSdkTypeRequest>
        Model::GetSdkTypeOutcomeCallable GetSdkTypeCallable(const GetSdkTypeRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetSdkType, request);
        }
 
        template<typename GetSdkTypeRequestT = Model::GetSdkTypeRequest>
        void GetSdkTypeAsync(const GetSdkTypeRequestT& request, const GetSdkTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetSdkType, request, handler, context);
        }
 
        virtual Model::GetSdkTypesOutcome GetSdkTypes(const Model::GetSdkTypesRequest& request = {}) const;
 
        template<typename GetSdkTypesRequestT = Model::GetSdkTypesRequest>
        Model::GetSdkTypesOutcomeCallable GetSdkTypesCallable(const GetSdkTypesRequestT& request = {}) const
        {
            return SubmitCallable(&APIGatewayClient::GetSdkTypes, request);
        }
 
        template<typename GetSdkTypesRequestT = Model::GetSdkTypesRequest>
        void GetSdkTypesAsync(const GetSdkTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSdkTypesRequestT& request = {}) const
        {
            return SubmitAsync(&APIGatewayClient::GetSdkTypes, request, handler, context);
        }
 
        virtual Model::GetStageOutcome GetStage(const Model::GetStageRequest& request) const;
 
        template<typename GetStageRequestT = Model::GetStageRequest>
        Model::GetStageOutcomeCallable GetStageCallable(const GetStageRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetStage, request);
        }
 
        template<typename GetStageRequestT = Model::GetStageRequest>
        void GetStageAsync(const GetStageRequestT& request, const GetStageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetStage, request, handler, context);
        }
 
        virtual Model::GetStagesOutcome GetStages(const Model::GetStagesRequest& request) const;
 
        template<typename GetStagesRequestT = Model::GetStagesRequest>
        Model::GetStagesOutcomeCallable GetStagesCallable(const GetStagesRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetStages, request);
        }
 
        template<typename GetStagesRequestT = Model::GetStagesRequest>
        void GetStagesAsync(const GetStagesRequestT& request, const GetStagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetStages, request, handler, context);
        }
 
        virtual Model::GetTagsOutcome GetTags(const Model::GetTagsRequest& request) const;
 
        template<typename GetTagsRequestT = Model::GetTagsRequest>
        Model::GetTagsOutcomeCallable GetTagsCallable(const GetTagsRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetTags, request);
        }
 
        template<typename GetTagsRequestT = Model::GetTagsRequest>
        void GetTagsAsync(const GetTagsRequestT& request, const GetTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetTags, request, handler, context);
        }
 
        virtual Model::GetUsageOutcome GetUsage(const Model::GetUsageRequest& request) const;
 
        template<typename GetUsageRequestT = Model::GetUsageRequest>
        Model::GetUsageOutcomeCallable GetUsageCallable(const GetUsageRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetUsage, request);
        }
 
        template<typename GetUsageRequestT = Model::GetUsageRequest>
        void GetUsageAsync(const GetUsageRequestT& request, const GetUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetUsage, request, handler, context);
        }
 
        virtual Model::GetUsagePlanOutcome GetUsagePlan(const Model::GetUsagePlanRequest& request) const;
 
        template<typename GetUsagePlanRequestT = Model::GetUsagePlanRequest>
        Model::GetUsagePlanOutcomeCallable GetUsagePlanCallable(const GetUsagePlanRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetUsagePlan, request);
        }
 
        template<typename GetUsagePlanRequestT = Model::GetUsagePlanRequest>
        void GetUsagePlanAsync(const GetUsagePlanRequestT& request, const GetUsagePlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetUsagePlan, request, handler, context);
        }
 
        virtual Model::GetUsagePlanKeyOutcome GetUsagePlanKey(const Model::GetUsagePlanKeyRequest& request) const;
 
        template<typename GetUsagePlanKeyRequestT = Model::GetUsagePlanKeyRequest>
        Model::GetUsagePlanKeyOutcomeCallable GetUsagePlanKeyCallable(const GetUsagePlanKeyRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetUsagePlanKey, request);
        }
 
        template<typename GetUsagePlanKeyRequestT = Model::GetUsagePlanKeyRequest>
        void GetUsagePlanKeyAsync(const GetUsagePlanKeyRequestT& request, const GetUsagePlanKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetUsagePlanKey, request, handler, context);
        }
 
        virtual Model::GetUsagePlanKeysOutcome GetUsagePlanKeys(const Model::GetUsagePlanKeysRequest& request) const;
 
        template<typename GetUsagePlanKeysRequestT = Model::GetUsagePlanKeysRequest>
        Model::GetUsagePlanKeysOutcomeCallable GetUsagePlanKeysCallable(const GetUsagePlanKeysRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetUsagePlanKeys, request);
        }
 
        template<typename GetUsagePlanKeysRequestT = Model::GetUsagePlanKeysRequest>
        void GetUsagePlanKeysAsync(const GetUsagePlanKeysRequestT& request, const GetUsagePlanKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetUsagePlanKeys, request, handler, context);
        }
 
        virtual Model::GetUsagePlansOutcome GetUsagePlans(const Model::GetUsagePlansRequest& request = {}) const;
 
        template<typename GetUsagePlansRequestT = Model::GetUsagePlansRequest>
        Model::GetUsagePlansOutcomeCallable GetUsagePlansCallable(const GetUsagePlansRequestT& request = {}) const
        {
            return SubmitCallable(&APIGatewayClient::GetUsagePlans, request);
        }
 
        template<typename GetUsagePlansRequestT = Model::GetUsagePlansRequest>
        void GetUsagePlansAsync(const GetUsagePlansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetUsagePlansRequestT& request = {}) const
        {
            return SubmitAsync(&APIGatewayClient::GetUsagePlans, request, handler, context);
        }
 
        virtual Model::GetVpcLinkOutcome GetVpcLink(const Model::GetVpcLinkRequest& request) const;
 
        template<typename GetVpcLinkRequestT = Model::GetVpcLinkRequest>
        Model::GetVpcLinkOutcomeCallable GetVpcLinkCallable(const GetVpcLinkRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::GetVpcLink, request);
        }
 
        template<typename GetVpcLinkRequestT = Model::GetVpcLinkRequest>
        void GetVpcLinkAsync(const GetVpcLinkRequestT& request, const GetVpcLinkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::GetVpcLink, request, handler, context);
        }
 
        virtual Model::GetVpcLinksOutcome GetVpcLinks(const Model::GetVpcLinksRequest& request = {}) const;
 
        template<typename GetVpcLinksRequestT = Model::GetVpcLinksRequest>
        Model::GetVpcLinksOutcomeCallable GetVpcLinksCallable(const GetVpcLinksRequestT& request = {}) const
        {
            return SubmitCallable(&APIGatewayClient::GetVpcLinks, request);
        }
 
        template<typename GetVpcLinksRequestT = Model::GetVpcLinksRequest>
        void GetVpcLinksAsync(const GetVpcLinksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetVpcLinksRequestT& request = {}) const
        {
            return SubmitAsync(&APIGatewayClient::GetVpcLinks, request, handler, context);
        }
 
        virtual Model::ImportApiKeysOutcome ImportApiKeys(const Model::ImportApiKeysRequest& request) const;
 
        template<typename ImportApiKeysRequestT = Model::ImportApiKeysRequest>
        Model::ImportApiKeysOutcomeCallable ImportApiKeysCallable(const ImportApiKeysRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::ImportApiKeys, request);
        }
 
        template<typename ImportApiKeysRequestT = Model::ImportApiKeysRequest>
        void ImportApiKeysAsync(const ImportApiKeysRequestT& request, const ImportApiKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::ImportApiKeys, request, handler, context);
        }
 
        virtual Model::ImportDocumentationPartsOutcome ImportDocumentationParts(const Model::ImportDocumentationPartsRequest& request) const;
 
        template<typename ImportDocumentationPartsRequestT = Model::ImportDocumentationPartsRequest>
        Model::ImportDocumentationPartsOutcomeCallable ImportDocumentationPartsCallable(const ImportDocumentationPartsRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::ImportDocumentationParts, request);
        }
 
        template<typename ImportDocumentationPartsRequestT = Model::ImportDocumentationPartsRequest>
        void ImportDocumentationPartsAsync(const ImportDocumentationPartsRequestT& request, const ImportDocumentationPartsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::ImportDocumentationParts, request, handler, context);
        }
 
        virtual Model::ImportRestApiOutcome ImportRestApi(const Model::ImportRestApiRequest& request) const;
 
        template<typename ImportRestApiRequestT = Model::ImportRestApiRequest>
        Model::ImportRestApiOutcomeCallable ImportRestApiCallable(const ImportRestApiRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::ImportRestApi, request);
        }
 
        template<typename ImportRestApiRequestT = Model::ImportRestApiRequest>
        void ImportRestApiAsync(const ImportRestApiRequestT& request, const ImportRestApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::ImportRestApi, request, handler, context);
        }
 
        virtual Model::PutGatewayResponseOutcome PutGatewayResponse(const Model::PutGatewayResponseRequest& request) const;
 
        template<typename PutGatewayResponseRequestT = Model::PutGatewayResponseRequest>
        Model::PutGatewayResponseOutcomeCallable PutGatewayResponseCallable(const PutGatewayResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::PutGatewayResponse, request);
        }
 
        template<typename PutGatewayResponseRequestT = Model::PutGatewayResponseRequest>
        void PutGatewayResponseAsync(const PutGatewayResponseRequestT& request, const PutGatewayResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::PutGatewayResponse, request, handler, context);
        }
 
        virtual Model::PutIntegrationOutcome PutIntegration(const Model::PutIntegrationRequest& request) const;
 
        template<typename PutIntegrationRequestT = Model::PutIntegrationRequest>
        Model::PutIntegrationOutcomeCallable PutIntegrationCallable(const PutIntegrationRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::PutIntegration, request);
        }
 
        template<typename PutIntegrationRequestT = Model::PutIntegrationRequest>
        void PutIntegrationAsync(const PutIntegrationRequestT& request, const PutIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::PutIntegration, request, handler, context);
        }
 
        virtual Model::PutIntegrationResponseOutcome PutIntegrationResponse(const Model::PutIntegrationResponseRequest& request) const;
 
        template<typename PutIntegrationResponseRequestT = Model::PutIntegrationResponseRequest>
        Model::PutIntegrationResponseOutcomeCallable PutIntegrationResponseCallable(const PutIntegrationResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::PutIntegrationResponse, request);
        }
 
        template<typename PutIntegrationResponseRequestT = Model::PutIntegrationResponseRequest>
        void PutIntegrationResponseAsync(const PutIntegrationResponseRequestT& request, const PutIntegrationResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::PutIntegrationResponse, request, handler, context);
        }
 
        virtual Model::PutMethodOutcome PutMethod(const Model::PutMethodRequest& request) const;
 
        template<typename PutMethodRequestT = Model::PutMethodRequest>
        Model::PutMethodOutcomeCallable PutMethodCallable(const PutMethodRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::PutMethod, request);
        }
 
        template<typename PutMethodRequestT = Model::PutMethodRequest>
        void PutMethodAsync(const PutMethodRequestT& request, const PutMethodResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::PutMethod, request, handler, context);
        }
 
        virtual Model::PutMethodResponseOutcome PutMethodResponse(const Model::PutMethodResponseRequest& request) const;
 
        template<typename PutMethodResponseRequestT = Model::PutMethodResponseRequest>
        Model::PutMethodResponseOutcomeCallable PutMethodResponseCallable(const PutMethodResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::PutMethodResponse, request);
        }
 
        template<typename PutMethodResponseRequestT = Model::PutMethodResponseRequest>
        void PutMethodResponseAsync(const PutMethodResponseRequestT& request, const PutMethodResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::PutMethodResponse, request, handler, context);
        }
 
        virtual Model::PutRestApiOutcome PutRestApi(const Model::PutRestApiRequest& request) const;
 
        template<typename PutRestApiRequestT = Model::PutRestApiRequest>
        Model::PutRestApiOutcomeCallable PutRestApiCallable(const PutRestApiRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::PutRestApi, request);
        }
 
        template<typename PutRestApiRequestT = Model::PutRestApiRequest>
        void PutRestApiAsync(const PutRestApiRequestT& request, const PutRestApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::PutRestApi, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::TagResource, request, handler, context);
        }
 
        virtual Model::TestInvokeAuthorizerOutcome TestInvokeAuthorizer(const Model::TestInvokeAuthorizerRequest& request) const;
 
        template<typename TestInvokeAuthorizerRequestT = Model::TestInvokeAuthorizerRequest>
        Model::TestInvokeAuthorizerOutcomeCallable TestInvokeAuthorizerCallable(const TestInvokeAuthorizerRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::TestInvokeAuthorizer, request);
        }
 
        template<typename TestInvokeAuthorizerRequestT = Model::TestInvokeAuthorizerRequest>
        void TestInvokeAuthorizerAsync(const TestInvokeAuthorizerRequestT& request, const TestInvokeAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::TestInvokeAuthorizer, request, handler, context);
        }
 
        virtual Model::TestInvokeMethodOutcome TestInvokeMethod(const Model::TestInvokeMethodRequest& request) const;
 
        template<typename TestInvokeMethodRequestT = Model::TestInvokeMethodRequest>
        Model::TestInvokeMethodOutcomeCallable TestInvokeMethodCallable(const TestInvokeMethodRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::TestInvokeMethod, request);
        }
 
        template<typename TestInvokeMethodRequestT = Model::TestInvokeMethodRequest>
        void TestInvokeMethodAsync(const TestInvokeMethodRequestT& request, const TestInvokeMethodResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::TestInvokeMethod, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAccountOutcome UpdateAccount(const Model::UpdateAccountRequest& request = {}) const;
 
        template<typename UpdateAccountRequestT = Model::UpdateAccountRequest>
        Model::UpdateAccountOutcomeCallable UpdateAccountCallable(const UpdateAccountRequestT& request = {}) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateAccount, request);
        }
 
        template<typename UpdateAccountRequestT = Model::UpdateAccountRequest>
        void UpdateAccountAsync(const UpdateAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateAccountRequestT& request = {}) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateAccount, request, handler, context);
        }
 
        virtual Model::UpdateApiKeyOutcome UpdateApiKey(const Model::UpdateApiKeyRequest& request) const;
 
        template<typename UpdateApiKeyRequestT = Model::UpdateApiKeyRequest>
        Model::UpdateApiKeyOutcomeCallable UpdateApiKeyCallable(const UpdateApiKeyRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateApiKey, request);
        }
 
        template<typename UpdateApiKeyRequestT = Model::UpdateApiKeyRequest>
        void UpdateApiKeyAsync(const UpdateApiKeyRequestT& request, const UpdateApiKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateApiKey, request, handler, context);
        }
 
        virtual Model::UpdateAuthorizerOutcome UpdateAuthorizer(const Model::UpdateAuthorizerRequest& request) const;
 
        template<typename UpdateAuthorizerRequestT = Model::UpdateAuthorizerRequest>
        Model::UpdateAuthorizerOutcomeCallable UpdateAuthorizerCallable(const UpdateAuthorizerRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateAuthorizer, request);
        }
 
        template<typename UpdateAuthorizerRequestT = Model::UpdateAuthorizerRequest>
        void UpdateAuthorizerAsync(const UpdateAuthorizerRequestT& request, const UpdateAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateAuthorizer, request, handler, context);
        }
 
        virtual Model::UpdateBasePathMappingOutcome UpdateBasePathMapping(const Model::UpdateBasePathMappingRequest& request) const;
 
        template<typename UpdateBasePathMappingRequestT = Model::UpdateBasePathMappingRequest>
        Model::UpdateBasePathMappingOutcomeCallable UpdateBasePathMappingCallable(const UpdateBasePathMappingRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateBasePathMapping, request);
        }
 
        template<typename UpdateBasePathMappingRequestT = Model::UpdateBasePathMappingRequest>
        void UpdateBasePathMappingAsync(const UpdateBasePathMappingRequestT& request, const UpdateBasePathMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateBasePathMapping, request, handler, context);
        }
 
        virtual Model::UpdateClientCertificateOutcome UpdateClientCertificate(const Model::UpdateClientCertificateRequest& request) const;
 
        template<typename UpdateClientCertificateRequestT = Model::UpdateClientCertificateRequest>
        Model::UpdateClientCertificateOutcomeCallable UpdateClientCertificateCallable(const UpdateClientCertificateRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateClientCertificate, request);
        }
 
        template<typename UpdateClientCertificateRequestT = Model::UpdateClientCertificateRequest>
        void UpdateClientCertificateAsync(const UpdateClientCertificateRequestT& request, const UpdateClientCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateClientCertificate, request, handler, context);
        }
 
        virtual Model::UpdateDeploymentOutcome UpdateDeployment(const Model::UpdateDeploymentRequest& request) const;
 
        template<typename UpdateDeploymentRequestT = Model::UpdateDeploymentRequest>
        Model::UpdateDeploymentOutcomeCallable UpdateDeploymentCallable(const UpdateDeploymentRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateDeployment, request);
        }
 
        template<typename UpdateDeploymentRequestT = Model::UpdateDeploymentRequest>
        void UpdateDeploymentAsync(const UpdateDeploymentRequestT& request, const UpdateDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateDeployment, request, handler, context);
        }
 
        virtual Model::UpdateDocumentationPartOutcome UpdateDocumentationPart(const Model::UpdateDocumentationPartRequest& request) const;
 
        template<typename UpdateDocumentationPartRequestT = Model::UpdateDocumentationPartRequest>
        Model::UpdateDocumentationPartOutcomeCallable UpdateDocumentationPartCallable(const UpdateDocumentationPartRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateDocumentationPart, request);
        }
 
        template<typename UpdateDocumentationPartRequestT = Model::UpdateDocumentationPartRequest>
        void UpdateDocumentationPartAsync(const UpdateDocumentationPartRequestT& request, const UpdateDocumentationPartResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateDocumentationPart, request, handler, context);
        }
 
        virtual Model::UpdateDocumentationVersionOutcome UpdateDocumentationVersion(const Model::UpdateDocumentationVersionRequest& request) const;
 
        template<typename UpdateDocumentationVersionRequestT = Model::UpdateDocumentationVersionRequest>
        Model::UpdateDocumentationVersionOutcomeCallable UpdateDocumentationVersionCallable(const UpdateDocumentationVersionRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateDocumentationVersion, request);
        }
 
        template<typename UpdateDocumentationVersionRequestT = Model::UpdateDocumentationVersionRequest>
        void UpdateDocumentationVersionAsync(const UpdateDocumentationVersionRequestT& request, const UpdateDocumentationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateDocumentationVersion, request, handler, context);
        }
 
        virtual Model::UpdateDomainNameOutcome UpdateDomainName(const Model::UpdateDomainNameRequest& request) const;
 
        template<typename UpdateDomainNameRequestT = Model::UpdateDomainNameRequest>
        Model::UpdateDomainNameOutcomeCallable UpdateDomainNameCallable(const UpdateDomainNameRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateDomainName, request);
        }
 
        template<typename UpdateDomainNameRequestT = Model::UpdateDomainNameRequest>
        void UpdateDomainNameAsync(const UpdateDomainNameRequestT& request, const UpdateDomainNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateDomainName, request, handler, context);
        }
 
        virtual Model::UpdateGatewayResponseOutcome UpdateGatewayResponse(const Model::UpdateGatewayResponseRequest& request) const;
 
        template<typename UpdateGatewayResponseRequestT = Model::UpdateGatewayResponseRequest>
        Model::UpdateGatewayResponseOutcomeCallable UpdateGatewayResponseCallable(const UpdateGatewayResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateGatewayResponse, request);
        }
 
        template<typename UpdateGatewayResponseRequestT = Model::UpdateGatewayResponseRequest>
        void UpdateGatewayResponseAsync(const UpdateGatewayResponseRequestT& request, const UpdateGatewayResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateGatewayResponse, request, handler, context);
        }
 
        virtual Model::UpdateIntegrationOutcome UpdateIntegration(const Model::UpdateIntegrationRequest& request) const;
 
        template<typename UpdateIntegrationRequestT = Model::UpdateIntegrationRequest>
        Model::UpdateIntegrationOutcomeCallable UpdateIntegrationCallable(const UpdateIntegrationRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateIntegration, request);
        }
 
        template<typename UpdateIntegrationRequestT = Model::UpdateIntegrationRequest>
        void UpdateIntegrationAsync(const UpdateIntegrationRequestT& request, const UpdateIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateIntegration, request, handler, context);
        }
 
        virtual Model::UpdateIntegrationResponseOutcome UpdateIntegrationResponse(const Model::UpdateIntegrationResponseRequest& request) const;
 
        template<typename UpdateIntegrationResponseRequestT = Model::UpdateIntegrationResponseRequest>
        Model::UpdateIntegrationResponseOutcomeCallable UpdateIntegrationResponseCallable(const UpdateIntegrationResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateIntegrationResponse, request);
        }
 
        template<typename UpdateIntegrationResponseRequestT = Model::UpdateIntegrationResponseRequest>
        void UpdateIntegrationResponseAsync(const UpdateIntegrationResponseRequestT& request, const UpdateIntegrationResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateIntegrationResponse, request, handler, context);
        }
 
        virtual Model::UpdateMethodOutcome UpdateMethod(const Model::UpdateMethodRequest& request) const;
 
        template<typename UpdateMethodRequestT = Model::UpdateMethodRequest>
        Model::UpdateMethodOutcomeCallable UpdateMethodCallable(const UpdateMethodRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateMethod, request);
        }
 
        template<typename UpdateMethodRequestT = Model::UpdateMethodRequest>
        void UpdateMethodAsync(const UpdateMethodRequestT& request, const UpdateMethodResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateMethod, request, handler, context);
        }
 
        virtual Model::UpdateMethodResponseOutcome UpdateMethodResponse(const Model::UpdateMethodResponseRequest& request) const;
 
        template<typename UpdateMethodResponseRequestT = Model::UpdateMethodResponseRequest>
        Model::UpdateMethodResponseOutcomeCallable UpdateMethodResponseCallable(const UpdateMethodResponseRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateMethodResponse, request);
        }
 
        template<typename UpdateMethodResponseRequestT = Model::UpdateMethodResponseRequest>
        void UpdateMethodResponseAsync(const UpdateMethodResponseRequestT& request, const UpdateMethodResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateMethodResponse, request, handler, context);
        }
 
        virtual Model::UpdateModelOutcome UpdateModel(const Model::UpdateModelRequest& request) const;
 
        template<typename UpdateModelRequestT = Model::UpdateModelRequest>
        Model::UpdateModelOutcomeCallable UpdateModelCallable(const UpdateModelRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateModel, request);
        }
 
        template<typename UpdateModelRequestT = Model::UpdateModelRequest>
        void UpdateModelAsync(const UpdateModelRequestT& request, const UpdateModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateModel, request, handler, context);
        }
 
        virtual Model::UpdateRequestValidatorOutcome UpdateRequestValidator(const Model::UpdateRequestValidatorRequest& request) const;
 
        template<typename UpdateRequestValidatorRequestT = Model::UpdateRequestValidatorRequest>
        Model::UpdateRequestValidatorOutcomeCallable UpdateRequestValidatorCallable(const UpdateRequestValidatorRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateRequestValidator, request);
        }
 
        template<typename UpdateRequestValidatorRequestT = Model::UpdateRequestValidatorRequest>
        void UpdateRequestValidatorAsync(const UpdateRequestValidatorRequestT& request, const UpdateRequestValidatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateRequestValidator, request, handler, context);
        }
 
        virtual Model::UpdateResourceOutcome UpdateResource(const Model::UpdateResourceRequest& request) const;
 
        template<typename UpdateResourceRequestT = Model::UpdateResourceRequest>
        Model::UpdateResourceOutcomeCallable UpdateResourceCallable(const UpdateResourceRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateResource, request);
        }
 
        template<typename UpdateResourceRequestT = Model::UpdateResourceRequest>
        void UpdateResourceAsync(const UpdateResourceRequestT& request, const UpdateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateResource, request, handler, context);
        }
 
        virtual Model::UpdateRestApiOutcome UpdateRestApi(const Model::UpdateRestApiRequest& request) const;
 
        template<typename UpdateRestApiRequestT = Model::UpdateRestApiRequest>
        Model::UpdateRestApiOutcomeCallable UpdateRestApiCallable(const UpdateRestApiRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateRestApi, request);
        }
 
        template<typename UpdateRestApiRequestT = Model::UpdateRestApiRequest>
        void UpdateRestApiAsync(const UpdateRestApiRequestT& request, const UpdateRestApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateRestApi, request, handler, context);
        }
 
        virtual Model::UpdateStageOutcome UpdateStage(const Model::UpdateStageRequest& request) const;
 
        template<typename UpdateStageRequestT = Model::UpdateStageRequest>
        Model::UpdateStageOutcomeCallable UpdateStageCallable(const UpdateStageRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateStage, request);
        }
 
        template<typename UpdateStageRequestT = Model::UpdateStageRequest>
        void UpdateStageAsync(const UpdateStageRequestT& request, const UpdateStageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateStage, request, handler, context);
        }
 
        virtual Model::UpdateUsageOutcome UpdateUsage(const Model::UpdateUsageRequest& request) const;
 
        template<typename UpdateUsageRequestT = Model::UpdateUsageRequest>
        Model::UpdateUsageOutcomeCallable UpdateUsageCallable(const UpdateUsageRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateUsage, request);
        }
 
        template<typename UpdateUsageRequestT = Model::UpdateUsageRequest>
        void UpdateUsageAsync(const UpdateUsageRequestT& request, const UpdateUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateUsage, request, handler, context);
        }
 
        virtual Model::UpdateUsagePlanOutcome UpdateUsagePlan(const Model::UpdateUsagePlanRequest& request) const;
 
        template<typename UpdateUsagePlanRequestT = Model::UpdateUsagePlanRequest>
        Model::UpdateUsagePlanOutcomeCallable UpdateUsagePlanCallable(const UpdateUsagePlanRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateUsagePlan, request);
        }
 
        template<typename UpdateUsagePlanRequestT = Model::UpdateUsagePlanRequest>
        void UpdateUsagePlanAsync(const UpdateUsagePlanRequestT& request, const UpdateUsagePlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateUsagePlan, request, handler, context);
        }
 
        virtual Model::UpdateVpcLinkOutcome UpdateVpcLink(const Model::UpdateVpcLinkRequest& request) const;
 
        template<typename UpdateVpcLinkRequestT = Model::UpdateVpcLinkRequest>
        Model::UpdateVpcLinkOutcomeCallable UpdateVpcLinkCallable(const UpdateVpcLinkRequestT& request) const
        {
            return SubmitCallable(&APIGatewayClient::UpdateVpcLink, request);
        }
 
        template<typename UpdateVpcLinkRequestT = Model::UpdateVpcLinkRequest>
        void UpdateVpcLinkAsync(const UpdateVpcLinkRequestT& request, const UpdateVpcLinkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&APIGatewayClient::UpdateVpcLink, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<APIGatewayEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<APIGatewayClient>;
      void init(const APIGatewayClientConfiguration& clientConfiguration);
 
      APIGatewayClientConfiguration m_clientConfiguration;
      std::shared_ptr<APIGatewayEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace APIGateway
} // namespace Aws