APIGatewayClient.h

 
#pragma once
#include <aws/apigateway/APIGatewayPaginationBase.h>
#include <aws/apigateway/APIGatewayServiceClientModel.h>
#include <aws/apigateway/APIGatewayWaiter.h>
#include <aws/apigateway/APIGateway_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace APIGateway {
class AWS_APIGATEWAY_API APIGatewayClient : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<APIGatewayClient>,
                                            public APIGatewayPaginationBase<APIGatewayClient>,
                                            public APIGatewayWaiter<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::CreateDomainNameAccessAssociationOutcome CreateDomainNameAccessAssociation(
      const Model::CreateDomainNameAccessAssociationRequest& request) const;
 
  template <typename CreateDomainNameAccessAssociationRequestT = Model::CreateDomainNameAccessAssociationRequest>
  Model::CreateDomainNameAccessAssociationOutcomeCallable CreateDomainNameAccessAssociationCallable(
      const CreateDomainNameAccessAssociationRequestT& request) const {
    return SubmitCallable(&APIGatewayClient::CreateDomainNameAccessAssociation, request);
  }
 
  template <typename CreateDomainNameAccessAssociationRequestT = Model::CreateDomainNameAccessAssociationRequest>
  void CreateDomainNameAccessAssociationAsync(const CreateDomainNameAccessAssociationRequestT& request,
                                              const CreateDomainNameAccessAssociationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&APIGatewayClient::CreateDomainNameAccessAssociation, 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::DeleteDomainNameAccessAssociationOutcome DeleteDomainNameAccessAssociation(
      const Model::DeleteDomainNameAccessAssociationRequest& request) const;
 
  template <typename DeleteDomainNameAccessAssociationRequestT = Model::DeleteDomainNameAccessAssociationRequest>
  Model::DeleteDomainNameAccessAssociationOutcomeCallable DeleteDomainNameAccessAssociationCallable(
      const DeleteDomainNameAccessAssociationRequestT& request) const {
    return SubmitCallable(&APIGatewayClient::DeleteDomainNameAccessAssociation, request);
  }
 
  template <typename DeleteDomainNameAccessAssociationRequestT = Model::DeleteDomainNameAccessAssociationRequest>
  void DeleteDomainNameAccessAssociationAsync(const DeleteDomainNameAccessAssociationRequestT& request,
                                              const DeleteDomainNameAccessAssociationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&APIGatewayClient::DeleteDomainNameAccessAssociation, 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::GetDomainNameAccessAssociationsOutcome GetDomainNameAccessAssociations(
      const Model::GetDomainNameAccessAssociationsRequest& request = {}) const;
 
  template <typename GetDomainNameAccessAssociationsRequestT = Model::GetDomainNameAccessAssociationsRequest>
  Model::GetDomainNameAccessAssociationsOutcomeCallable GetDomainNameAccessAssociationsCallable(
      const GetDomainNameAccessAssociationsRequestT& request = {}) const {
    return SubmitCallable(&APIGatewayClient::GetDomainNameAccessAssociations, request);
  }
 
  template <typename GetDomainNameAccessAssociationsRequestT = Model::GetDomainNameAccessAssociationsRequest>
  void GetDomainNameAccessAssociationsAsync(const GetDomainNameAccessAssociationsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const GetDomainNameAccessAssociationsRequestT& request = {}) const {
    return SubmitAsync(&APIGatewayClient::GetDomainNameAccessAssociations, 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::RejectDomainNameAccessAssociationOutcome RejectDomainNameAccessAssociation(
      const Model::RejectDomainNameAccessAssociationRequest& request) const;
 
  template <typename RejectDomainNameAccessAssociationRequestT = Model::RejectDomainNameAccessAssociationRequest>
  Model::RejectDomainNameAccessAssociationOutcomeCallable RejectDomainNameAccessAssociationCallable(
      const RejectDomainNameAccessAssociationRequestT& request) const {
    return SubmitCallable(&APIGatewayClient::RejectDomainNameAccessAssociation, request);
  }
 
  template <typename RejectDomainNameAccessAssociationRequestT = Model::RejectDomainNameAccessAssociationRequest>
  void RejectDomainNameAccessAssociationAsync(const RejectDomainNameAccessAssociationRequestT& request,
                                              const RejectDomainNameAccessAssociationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&APIGatewayClient::RejectDomainNameAccessAssociation, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<APIGatewayEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<APIGatewayClient>;
  void init(const APIGatewayClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, APIGatewayError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  APIGatewayClientConfiguration m_clientConfiguration;
  std::shared_ptr<APIGatewayEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace APIGateway
}  // namespace Aws