ApiGatewayV2Client.h

 
#pragma once
#include <aws/apigatewayv2/ApiGatewayV2PaginationBase.h>
#include <aws/apigatewayv2/ApiGatewayV2ServiceClientModel.h>
#include <aws/apigatewayv2/ApiGatewayV2_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 ApiGatewayV2 {
class AWS_APIGATEWAYV2_API ApiGatewayV2Client : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<ApiGatewayV2Client>,
                                                public ApiGatewayV2PaginationBase<ApiGatewayV2Client> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ApiGatewayV2ClientConfiguration ClientConfigurationType;
  typedef ApiGatewayV2EndpointProvider EndpointProviderType;
 
  ApiGatewayV2Client(
      const Aws::ApiGatewayV2::ApiGatewayV2ClientConfiguration& clientConfiguration = Aws::ApiGatewayV2::ApiGatewayV2ClientConfiguration(),
      std::shared_ptr<ApiGatewayV2EndpointProviderBase> endpointProvider = nullptr);
 
  ApiGatewayV2Client(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<ApiGatewayV2EndpointProviderBase> endpointProvider = nullptr,
      const Aws::ApiGatewayV2::ApiGatewayV2ClientConfiguration& clientConfiguration = Aws::ApiGatewayV2::ApiGatewayV2ClientConfiguration());
 
  ApiGatewayV2Client(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<ApiGatewayV2EndpointProviderBase> endpointProvider = nullptr,
      const Aws::ApiGatewayV2::ApiGatewayV2ClientConfiguration& clientConfiguration = Aws::ApiGatewayV2::ApiGatewayV2ClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ApiGatewayV2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ApiGatewayV2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ApiGatewayV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ApiGatewayV2Client();
 
  virtual Model::CreateApiOutcome CreateApi(const Model::CreateApiRequest& request) const;
 
  template <typename CreateApiRequestT = Model::CreateApiRequest>
  Model::CreateApiOutcomeCallable CreateApiCallable(const CreateApiRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::CreateApi, request);
  }
 
  template <typename CreateApiRequestT = Model::CreateApiRequest>
  void CreateApiAsync(const CreateApiRequestT& request, const CreateApiResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::CreateApi, request, handler, context);
  }
 
  virtual Model::CreateApiMappingOutcome CreateApiMapping(const Model::CreateApiMappingRequest& request) const;
 
  template <typename CreateApiMappingRequestT = Model::CreateApiMappingRequest>
  Model::CreateApiMappingOutcomeCallable CreateApiMappingCallable(const CreateApiMappingRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::CreateApiMapping, request);
  }
 
  template <typename CreateApiMappingRequestT = Model::CreateApiMappingRequest>
  void CreateApiMappingAsync(const CreateApiMappingRequestT& request, const CreateApiMappingResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::CreateApiMapping, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::CreateAuthorizer, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::CreateDeployment, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::CreateDomainName, request, handler, context);
  }
 
  virtual Model::CreateIntegrationOutcome CreateIntegration(const Model::CreateIntegrationRequest& request) const;
 
  template <typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
  Model::CreateIntegrationOutcomeCallable CreateIntegrationCallable(const CreateIntegrationRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::CreateIntegration, request);
  }
 
  template <typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
  void CreateIntegrationAsync(const CreateIntegrationRequestT& request, const CreateIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::CreateIntegration, request, handler, context);
  }
 
  virtual Model::CreateIntegrationResponseOutcome CreateIntegrationResponse(const Model::CreateIntegrationResponseRequest& request) const;
 
  template <typename CreateIntegrationResponseRequestT = Model::CreateIntegrationResponseRequest>
  Model::CreateIntegrationResponseOutcomeCallable CreateIntegrationResponseCallable(
      const CreateIntegrationResponseRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::CreateIntegrationResponse, request);
  }
 
  template <typename CreateIntegrationResponseRequestT = Model::CreateIntegrationResponseRequest>
  void CreateIntegrationResponseAsync(const CreateIntegrationResponseRequestT& request,
                                      const CreateIntegrationResponseResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::CreateIntegrationResponse, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::CreateModel, request, handler, context);
  }
 
  virtual Model::CreatePortalOutcome CreatePortal(const Model::CreatePortalRequest& request) const;
 
  template <typename CreatePortalRequestT = Model::CreatePortalRequest>
  Model::CreatePortalOutcomeCallable CreatePortalCallable(const CreatePortalRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::CreatePortal, request);
  }
 
  template <typename CreatePortalRequestT = Model::CreatePortalRequest>
  void CreatePortalAsync(const CreatePortalRequestT& request, const CreatePortalResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::CreatePortal, request, handler, context);
  }
 
  virtual Model::CreatePortalProductOutcome CreatePortalProduct(const Model::CreatePortalProductRequest& request) const;
 
  template <typename CreatePortalProductRequestT = Model::CreatePortalProductRequest>
  Model::CreatePortalProductOutcomeCallable CreatePortalProductCallable(const CreatePortalProductRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::CreatePortalProduct, request);
  }
 
  template <typename CreatePortalProductRequestT = Model::CreatePortalProductRequest>
  void CreatePortalProductAsync(const CreatePortalProductRequestT& request, const CreatePortalProductResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::CreatePortalProduct, request, handler, context);
  }
 
  virtual Model::CreateProductPageOutcome CreateProductPage(const Model::CreateProductPageRequest& request) const;
 
  template <typename CreateProductPageRequestT = Model::CreateProductPageRequest>
  Model::CreateProductPageOutcomeCallable CreateProductPageCallable(const CreateProductPageRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::CreateProductPage, request);
  }
 
  template <typename CreateProductPageRequestT = Model::CreateProductPageRequest>
  void CreateProductPageAsync(const CreateProductPageRequestT& request, const CreateProductPageResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::CreateProductPage, request, handler, context);
  }
 
  virtual Model::CreateProductRestEndpointPageOutcome CreateProductRestEndpointPage(
      const Model::CreateProductRestEndpointPageRequest& request) const;
 
  template <typename CreateProductRestEndpointPageRequestT = Model::CreateProductRestEndpointPageRequest>
  Model::CreateProductRestEndpointPageOutcomeCallable CreateProductRestEndpointPageCallable(
      const CreateProductRestEndpointPageRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::CreateProductRestEndpointPage, request);
  }
 
  template <typename CreateProductRestEndpointPageRequestT = Model::CreateProductRestEndpointPageRequest>
  void CreateProductRestEndpointPageAsync(const CreateProductRestEndpointPageRequestT& request,
                                          const CreateProductRestEndpointPageResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::CreateProductRestEndpointPage, request, handler, context);
  }
 
  virtual Model::CreateRouteOutcome CreateRoute(const Model::CreateRouteRequest& request) const;
 
  template <typename CreateRouteRequestT = Model::CreateRouteRequest>
  Model::CreateRouteOutcomeCallable CreateRouteCallable(const CreateRouteRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::CreateRoute, request);
  }
 
  template <typename CreateRouteRequestT = Model::CreateRouteRequest>
  void CreateRouteAsync(const CreateRouteRequestT& request, const CreateRouteResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::CreateRoute, request, handler, context);
  }
 
  virtual Model::CreateRouteResponseOutcome CreateRouteResponse(const Model::CreateRouteResponseRequest& request) const;
 
  template <typename CreateRouteResponseRequestT = Model::CreateRouteResponseRequest>
  Model::CreateRouteResponseOutcomeCallable CreateRouteResponseCallable(const CreateRouteResponseRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::CreateRouteResponse, request);
  }
 
  template <typename CreateRouteResponseRequestT = Model::CreateRouteResponseRequest>
  void CreateRouteResponseAsync(const CreateRouteResponseRequestT& request, const CreateRouteResponseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::CreateRouteResponse, request, handler, context);
  }
 
  virtual Model::CreateRoutingRuleOutcome CreateRoutingRule(const Model::CreateRoutingRuleRequest& request) const;
 
  template <typename CreateRoutingRuleRequestT = Model::CreateRoutingRuleRequest>
  Model::CreateRoutingRuleOutcomeCallable CreateRoutingRuleCallable(const CreateRoutingRuleRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::CreateRoutingRule, request);
  }
 
  template <typename CreateRoutingRuleRequestT = Model::CreateRoutingRuleRequest>
  void CreateRoutingRuleAsync(const CreateRoutingRuleRequestT& request, const CreateRoutingRuleResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::CreateRoutingRule, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::CreateStage, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::CreateVpcLink, request, handler, context);
  }
 
  virtual Model::DeleteAccessLogSettingsOutcome DeleteAccessLogSettings(const Model::DeleteAccessLogSettingsRequest& request) const;
 
  template <typename DeleteAccessLogSettingsRequestT = Model::DeleteAccessLogSettingsRequest>
  Model::DeleteAccessLogSettingsOutcomeCallable DeleteAccessLogSettingsCallable(const DeleteAccessLogSettingsRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeleteAccessLogSettings, request);
  }
 
  template <typename DeleteAccessLogSettingsRequestT = Model::DeleteAccessLogSettingsRequest>
  void DeleteAccessLogSettingsAsync(const DeleteAccessLogSettingsRequestT& request,
                                    const DeleteAccessLogSettingsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeleteAccessLogSettings, request, handler, context);
  }
 
  virtual Model::DeleteApiOutcome DeleteApi(const Model::DeleteApiRequest& request) const;
 
  template <typename DeleteApiRequestT = Model::DeleteApiRequest>
  Model::DeleteApiOutcomeCallable DeleteApiCallable(const DeleteApiRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeleteApi, request);
  }
 
  template <typename DeleteApiRequestT = Model::DeleteApiRequest>
  void DeleteApiAsync(const DeleteApiRequestT& request, const DeleteApiResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeleteApi, request, handler, context);
  }
 
  virtual Model::DeleteApiMappingOutcome DeleteApiMapping(const Model::DeleteApiMappingRequest& request) const;
 
  template <typename DeleteApiMappingRequestT = Model::DeleteApiMappingRequest>
  Model::DeleteApiMappingOutcomeCallable DeleteApiMappingCallable(const DeleteApiMappingRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeleteApiMapping, request);
  }
 
  template <typename DeleteApiMappingRequestT = Model::DeleteApiMappingRequest>
  void DeleteApiMappingAsync(const DeleteApiMappingRequestT& request, const DeleteApiMappingResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeleteApiMapping, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::DeleteAuthorizer, request, handler, context);
  }
 
  virtual Model::DeleteCorsConfigurationOutcome DeleteCorsConfiguration(const Model::DeleteCorsConfigurationRequest& request) const;
 
  template <typename DeleteCorsConfigurationRequestT = Model::DeleteCorsConfigurationRequest>
  Model::DeleteCorsConfigurationOutcomeCallable DeleteCorsConfigurationCallable(const DeleteCorsConfigurationRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeleteCorsConfiguration, request);
  }
 
  template <typename DeleteCorsConfigurationRequestT = Model::DeleteCorsConfigurationRequest>
  void DeleteCorsConfigurationAsync(const DeleteCorsConfigurationRequestT& request,
                                    const DeleteCorsConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeleteCorsConfiguration, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::DeleteDeployment, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::DeleteDomainName, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::DeleteIntegrationResponse, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::DeleteModel, request, handler, context);
  }
 
  virtual Model::DeletePortalOutcome DeletePortal(const Model::DeletePortalRequest& request) const;
 
  template <typename DeletePortalRequestT = Model::DeletePortalRequest>
  Model::DeletePortalOutcomeCallable DeletePortalCallable(const DeletePortalRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeletePortal, request);
  }
 
  template <typename DeletePortalRequestT = Model::DeletePortalRequest>
  void DeletePortalAsync(const DeletePortalRequestT& request, const DeletePortalResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeletePortal, request, handler, context);
  }
 
  virtual Model::DeletePortalProductOutcome DeletePortalProduct(const Model::DeletePortalProductRequest& request) const;
 
  template <typename DeletePortalProductRequestT = Model::DeletePortalProductRequest>
  Model::DeletePortalProductOutcomeCallable DeletePortalProductCallable(const DeletePortalProductRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeletePortalProduct, request);
  }
 
  template <typename DeletePortalProductRequestT = Model::DeletePortalProductRequest>
  void DeletePortalProductAsync(const DeletePortalProductRequestT& request, const DeletePortalProductResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeletePortalProduct, request, handler, context);
  }
 
  virtual Model::DeletePortalProductSharingPolicyOutcome DeletePortalProductSharingPolicy(
      const Model::DeletePortalProductSharingPolicyRequest& request) const;
 
  template <typename DeletePortalProductSharingPolicyRequestT = Model::DeletePortalProductSharingPolicyRequest>
  Model::DeletePortalProductSharingPolicyOutcomeCallable DeletePortalProductSharingPolicyCallable(
      const DeletePortalProductSharingPolicyRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeletePortalProductSharingPolicy, request);
  }
 
  template <typename DeletePortalProductSharingPolicyRequestT = Model::DeletePortalProductSharingPolicyRequest>
  void DeletePortalProductSharingPolicyAsync(const DeletePortalProductSharingPolicyRequestT& request,
                                             const DeletePortalProductSharingPolicyResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeletePortalProductSharingPolicy, request, handler, context);
  }
 
  virtual Model::DeleteProductPageOutcome DeleteProductPage(const Model::DeleteProductPageRequest& request) const;
 
  template <typename DeleteProductPageRequestT = Model::DeleteProductPageRequest>
  Model::DeleteProductPageOutcomeCallable DeleteProductPageCallable(const DeleteProductPageRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeleteProductPage, request);
  }
 
  template <typename DeleteProductPageRequestT = Model::DeleteProductPageRequest>
  void DeleteProductPageAsync(const DeleteProductPageRequestT& request, const DeleteProductPageResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeleteProductPage, request, handler, context);
  }
 
  virtual Model::DeleteProductRestEndpointPageOutcome DeleteProductRestEndpointPage(
      const Model::DeleteProductRestEndpointPageRequest& request) const;
 
  template <typename DeleteProductRestEndpointPageRequestT = Model::DeleteProductRestEndpointPageRequest>
  Model::DeleteProductRestEndpointPageOutcomeCallable DeleteProductRestEndpointPageCallable(
      const DeleteProductRestEndpointPageRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeleteProductRestEndpointPage, request);
  }
 
  template <typename DeleteProductRestEndpointPageRequestT = Model::DeleteProductRestEndpointPageRequest>
  void DeleteProductRestEndpointPageAsync(const DeleteProductRestEndpointPageRequestT& request,
                                          const DeleteProductRestEndpointPageResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeleteProductRestEndpointPage, request, handler, context);
  }
 
  virtual Model::DeleteRouteOutcome DeleteRoute(const Model::DeleteRouteRequest& request) const;
 
  template <typename DeleteRouteRequestT = Model::DeleteRouteRequest>
  Model::DeleteRouteOutcomeCallable DeleteRouteCallable(const DeleteRouteRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeleteRoute, request);
  }
 
  template <typename DeleteRouteRequestT = Model::DeleteRouteRequest>
  void DeleteRouteAsync(const DeleteRouteRequestT& request, const DeleteRouteResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeleteRoute, request, handler, context);
  }
 
  virtual Model::DeleteRouteRequestParameterOutcome DeleteRouteRequestParameter(
      const Model::DeleteRouteRequestParameterRequest& request) const;
 
  template <typename DeleteRouteRequestParameterRequestT = Model::DeleteRouteRequestParameterRequest>
  Model::DeleteRouteRequestParameterOutcomeCallable DeleteRouteRequestParameterCallable(
      const DeleteRouteRequestParameterRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeleteRouteRequestParameter, request);
  }
 
  template <typename DeleteRouteRequestParameterRequestT = Model::DeleteRouteRequestParameterRequest>
  void DeleteRouteRequestParameterAsync(const DeleteRouteRequestParameterRequestT& request,
                                        const DeleteRouteRequestParameterResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeleteRouteRequestParameter, request, handler, context);
  }
 
  virtual Model::DeleteRouteResponseOutcome DeleteRouteResponse(const Model::DeleteRouteResponseRequest& request) const;
 
  template <typename DeleteRouteResponseRequestT = Model::DeleteRouteResponseRequest>
  Model::DeleteRouteResponseOutcomeCallable DeleteRouteResponseCallable(const DeleteRouteResponseRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeleteRouteResponse, request);
  }
 
  template <typename DeleteRouteResponseRequestT = Model::DeleteRouteResponseRequest>
  void DeleteRouteResponseAsync(const DeleteRouteResponseRequestT& request, const DeleteRouteResponseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeleteRouteResponse, request, handler, context);
  }
 
  virtual Model::DeleteRouteSettingsOutcome DeleteRouteSettings(const Model::DeleteRouteSettingsRequest& request) const;
 
  template <typename DeleteRouteSettingsRequestT = Model::DeleteRouteSettingsRequest>
  Model::DeleteRouteSettingsOutcomeCallable DeleteRouteSettingsCallable(const DeleteRouteSettingsRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeleteRouteSettings, request);
  }
 
  template <typename DeleteRouteSettingsRequestT = Model::DeleteRouteSettingsRequest>
  void DeleteRouteSettingsAsync(const DeleteRouteSettingsRequestT& request, const DeleteRouteSettingsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeleteRouteSettings, request, handler, context);
  }
 
  virtual Model::DeleteRoutingRuleOutcome DeleteRoutingRule(const Model::DeleteRoutingRuleRequest& request) const;
 
  template <typename DeleteRoutingRuleRequestT = Model::DeleteRoutingRuleRequest>
  Model::DeleteRoutingRuleOutcomeCallable DeleteRoutingRuleCallable(const DeleteRoutingRuleRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DeleteRoutingRule, request);
  }
 
  template <typename DeleteRoutingRuleRequestT = Model::DeleteRoutingRuleRequest>
  void DeleteRoutingRuleAsync(const DeleteRoutingRuleRequestT& request, const DeleteRoutingRuleResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DeleteRoutingRule, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::DeleteStage, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::DeleteVpcLink, request, handler, context);
  }
 
  virtual Model::DisablePortalOutcome DisablePortal(const Model::DisablePortalRequest& request) const;
 
  template <typename DisablePortalRequestT = Model::DisablePortalRequest>
  Model::DisablePortalOutcomeCallable DisablePortalCallable(const DisablePortalRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::DisablePortal, request);
  }
 
  template <typename DisablePortalRequestT = Model::DisablePortalRequest>
  void DisablePortalAsync(const DisablePortalRequestT& request, const DisablePortalResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::DisablePortal, request, handler, context);
  }
 
  virtual Model::ExportApiOutcome ExportApi(const Model::ExportApiRequest& request) const;
 
  template <typename ExportApiRequestT = Model::ExportApiRequest>
  Model::ExportApiOutcomeCallable ExportApiCallable(const ExportApiRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::ExportApi, request);
  }
 
  template <typename ExportApiRequestT = Model::ExportApiRequest>
  void ExportApiAsync(const ExportApiRequestT& request, const ExportApiResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::ExportApi, request, handler, context);
  }
 
  virtual Model::GetApiOutcome GetApi(const Model::GetApiRequest& request) const;
 
  template <typename GetApiRequestT = Model::GetApiRequest>
  Model::GetApiOutcomeCallable GetApiCallable(const GetApiRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetApi, request);
  }
 
  template <typename GetApiRequestT = Model::GetApiRequest>
  void GetApiAsync(const GetApiRequestT& request, const GetApiResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetApi, request, handler, context);
  }
 
  virtual Model::GetApiMappingOutcome GetApiMapping(const Model::GetApiMappingRequest& request) const;
 
  template <typename GetApiMappingRequestT = Model::GetApiMappingRequest>
  Model::GetApiMappingOutcomeCallable GetApiMappingCallable(const GetApiMappingRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetApiMapping, request);
  }
 
  template <typename GetApiMappingRequestT = Model::GetApiMappingRequest>
  void GetApiMappingAsync(const GetApiMappingRequestT& request, const GetApiMappingResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetApiMapping, request, handler, context);
  }
 
  virtual Model::GetApiMappingsOutcome GetApiMappings(const Model::GetApiMappingsRequest& request) const;
 
  template <typename GetApiMappingsRequestT = Model::GetApiMappingsRequest>
  Model::GetApiMappingsOutcomeCallable GetApiMappingsCallable(const GetApiMappingsRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetApiMappings, request);
  }
 
  template <typename GetApiMappingsRequestT = Model::GetApiMappingsRequest>
  void GetApiMappingsAsync(const GetApiMappingsRequestT& request, const GetApiMappingsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetApiMappings, request, handler, context);
  }
 
  virtual Model::GetApisOutcome GetApis(const Model::GetApisRequest& request = {}) const;
 
  template <typename GetApisRequestT = Model::GetApisRequest>
  Model::GetApisOutcomeCallable GetApisCallable(const GetApisRequestT& request = {}) const {
    return SubmitCallable(&ApiGatewayV2Client::GetApis, request);
  }
 
  template <typename GetApisRequestT = Model::GetApisRequest>
  void GetApisAsync(const GetApisResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                    const GetApisRequestT& request = {}) const {
    return SubmitAsync(&ApiGatewayV2Client::GetApis, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::GetAuthorizers, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::GetDeployments, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::GetDomainName, request, handler, context);
  }
 
  virtual Model::GetDomainNamesOutcome GetDomainNames(const Model::GetDomainNamesRequest& request = {}) const;
 
  template <typename GetDomainNamesRequestT = Model::GetDomainNamesRequest>
  Model::GetDomainNamesOutcomeCallable GetDomainNamesCallable(const GetDomainNamesRequestT& request = {}) const {
    return SubmitCallable(&ApiGatewayV2Client::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(&ApiGatewayV2Client::GetDomainNames, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::GetIntegrationResponse, request, handler, context);
  }
 
  virtual Model::GetIntegrationResponsesOutcome GetIntegrationResponses(const Model::GetIntegrationResponsesRequest& request) const;
 
  template <typename GetIntegrationResponsesRequestT = Model::GetIntegrationResponsesRequest>
  Model::GetIntegrationResponsesOutcomeCallable GetIntegrationResponsesCallable(const GetIntegrationResponsesRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetIntegrationResponses, request);
  }
 
  template <typename GetIntegrationResponsesRequestT = Model::GetIntegrationResponsesRequest>
  void GetIntegrationResponsesAsync(const GetIntegrationResponsesRequestT& request,
                                    const GetIntegrationResponsesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetIntegrationResponses, request, handler, context);
  }
 
  virtual Model::GetIntegrationsOutcome GetIntegrations(const Model::GetIntegrationsRequest& request) const;
 
  template <typename GetIntegrationsRequestT = Model::GetIntegrationsRequest>
  Model::GetIntegrationsOutcomeCallable GetIntegrationsCallable(const GetIntegrationsRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetIntegrations, request);
  }
 
  template <typename GetIntegrationsRequestT = Model::GetIntegrationsRequest>
  void GetIntegrationsAsync(const GetIntegrationsRequestT& request, const GetIntegrationsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetIntegrations, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::GetModels, request, handler, context);
  }
 
  virtual Model::GetPortalOutcome GetPortal(const Model::GetPortalRequest& request) const;
 
  template <typename GetPortalRequestT = Model::GetPortalRequest>
  Model::GetPortalOutcomeCallable GetPortalCallable(const GetPortalRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetPortal, request);
  }
 
  template <typename GetPortalRequestT = Model::GetPortalRequest>
  void GetPortalAsync(const GetPortalRequestT& request, const GetPortalResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetPortal, request, handler, context);
  }
 
  virtual Model::GetPortalProductOutcome GetPortalProduct(const Model::GetPortalProductRequest& request) const;
 
  template <typename GetPortalProductRequestT = Model::GetPortalProductRequest>
  Model::GetPortalProductOutcomeCallable GetPortalProductCallable(const GetPortalProductRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetPortalProduct, request);
  }
 
  template <typename GetPortalProductRequestT = Model::GetPortalProductRequest>
  void GetPortalProductAsync(const GetPortalProductRequestT& request, const GetPortalProductResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetPortalProduct, request, handler, context);
  }
 
  virtual Model::GetPortalProductSharingPolicyOutcome GetPortalProductSharingPolicy(
      const Model::GetPortalProductSharingPolicyRequest& request) const;
 
  template <typename GetPortalProductSharingPolicyRequestT = Model::GetPortalProductSharingPolicyRequest>
  Model::GetPortalProductSharingPolicyOutcomeCallable GetPortalProductSharingPolicyCallable(
      const GetPortalProductSharingPolicyRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetPortalProductSharingPolicy, request);
  }
 
  template <typename GetPortalProductSharingPolicyRequestT = Model::GetPortalProductSharingPolicyRequest>
  void GetPortalProductSharingPolicyAsync(const GetPortalProductSharingPolicyRequestT& request,
                                          const GetPortalProductSharingPolicyResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetPortalProductSharingPolicy, request, handler, context);
  }
 
  virtual Model::GetProductPageOutcome GetProductPage(const Model::GetProductPageRequest& request) const;
 
  template <typename GetProductPageRequestT = Model::GetProductPageRequest>
  Model::GetProductPageOutcomeCallable GetProductPageCallable(const GetProductPageRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetProductPage, request);
  }
 
  template <typename GetProductPageRequestT = Model::GetProductPageRequest>
  void GetProductPageAsync(const GetProductPageRequestT& request, const GetProductPageResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetProductPage, request, handler, context);
  }
 
  virtual Model::GetProductRestEndpointPageOutcome GetProductRestEndpointPage(
      const Model::GetProductRestEndpointPageRequest& request) const;
 
  template <typename GetProductRestEndpointPageRequestT = Model::GetProductRestEndpointPageRequest>
  Model::GetProductRestEndpointPageOutcomeCallable GetProductRestEndpointPageCallable(
      const GetProductRestEndpointPageRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetProductRestEndpointPage, request);
  }
 
  template <typename GetProductRestEndpointPageRequestT = Model::GetProductRestEndpointPageRequest>
  void GetProductRestEndpointPageAsync(const GetProductRestEndpointPageRequestT& request,
                                       const GetProductRestEndpointPageResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetProductRestEndpointPage, request, handler, context);
  }
 
  virtual Model::GetRouteOutcome GetRoute(const Model::GetRouteRequest& request) const;
 
  template <typename GetRouteRequestT = Model::GetRouteRequest>
  Model::GetRouteOutcomeCallable GetRouteCallable(const GetRouteRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetRoute, request);
  }
 
  template <typename GetRouteRequestT = Model::GetRouteRequest>
  void GetRouteAsync(const GetRouteRequestT& request, const GetRouteResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetRoute, request, handler, context);
  }
 
  virtual Model::GetRouteResponseOutcome GetRouteResponse(const Model::GetRouteResponseRequest& request) const;
 
  template <typename GetRouteResponseRequestT = Model::GetRouteResponseRequest>
  Model::GetRouteResponseOutcomeCallable GetRouteResponseCallable(const GetRouteResponseRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetRouteResponse, request);
  }
 
  template <typename GetRouteResponseRequestT = Model::GetRouteResponseRequest>
  void GetRouteResponseAsync(const GetRouteResponseRequestT& request, const GetRouteResponseResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetRouteResponse, request, handler, context);
  }
 
  virtual Model::GetRouteResponsesOutcome GetRouteResponses(const Model::GetRouteResponsesRequest& request) const;
 
  template <typename GetRouteResponsesRequestT = Model::GetRouteResponsesRequest>
  Model::GetRouteResponsesOutcomeCallable GetRouteResponsesCallable(const GetRouteResponsesRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetRouteResponses, request);
  }
 
  template <typename GetRouteResponsesRequestT = Model::GetRouteResponsesRequest>
  void GetRouteResponsesAsync(const GetRouteResponsesRequestT& request, const GetRouteResponsesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetRouteResponses, request, handler, context);
  }
 
  virtual Model::GetRoutesOutcome GetRoutes(const Model::GetRoutesRequest& request) const;
 
  template <typename GetRoutesRequestT = Model::GetRoutesRequest>
  Model::GetRoutesOutcomeCallable GetRoutesCallable(const GetRoutesRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetRoutes, request);
  }
 
  template <typename GetRoutesRequestT = Model::GetRoutesRequest>
  void GetRoutesAsync(const GetRoutesRequestT& request, const GetRoutesResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetRoutes, request, handler, context);
  }
 
  virtual Model::GetRoutingRuleOutcome GetRoutingRule(const Model::GetRoutingRuleRequest& request) const;
 
  template <typename GetRoutingRuleRequestT = Model::GetRoutingRuleRequest>
  Model::GetRoutingRuleOutcomeCallable GetRoutingRuleCallable(const GetRoutingRuleRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::GetRoutingRule, request);
  }
 
  template <typename GetRoutingRuleRequestT = Model::GetRoutingRuleRequest>
  void GetRoutingRuleAsync(const GetRoutingRuleRequestT& request, const GetRoutingRuleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::GetRoutingRule, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::GetTags, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::GetVpcLinks, request, handler, context);
  }
 
  virtual Model::ImportApiOutcome ImportApi(const Model::ImportApiRequest& request) const;
 
  template <typename ImportApiRequestT = Model::ImportApiRequest>
  Model::ImportApiOutcomeCallable ImportApiCallable(const ImportApiRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::ImportApi, request);
  }
 
  template <typename ImportApiRequestT = Model::ImportApiRequest>
  void ImportApiAsync(const ImportApiRequestT& request, const ImportApiResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::ImportApi, request, handler, context);
  }
 
  virtual Model::ListPortalProductsOutcome ListPortalProducts(const Model::ListPortalProductsRequest& request = {}) const;
 
  template <typename ListPortalProductsRequestT = Model::ListPortalProductsRequest>
  Model::ListPortalProductsOutcomeCallable ListPortalProductsCallable(const ListPortalProductsRequestT& request = {}) const {
    return SubmitCallable(&ApiGatewayV2Client::ListPortalProducts, request);
  }
 
  template <typename ListPortalProductsRequestT = Model::ListPortalProductsRequest>
  void ListPortalProductsAsync(const ListPortalProductsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListPortalProductsRequestT& request = {}) const {
    return SubmitAsync(&ApiGatewayV2Client::ListPortalProducts, request, handler, context);
  }
 
  virtual Model::ListPortalsOutcome ListPortals(const Model::ListPortalsRequest& request = {}) const;
 
  template <typename ListPortalsRequestT = Model::ListPortalsRequest>
  Model::ListPortalsOutcomeCallable ListPortalsCallable(const ListPortalsRequestT& request = {}) const {
    return SubmitCallable(&ApiGatewayV2Client::ListPortals, request);
  }
 
  template <typename ListPortalsRequestT = Model::ListPortalsRequest>
  void ListPortalsAsync(const ListPortalsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListPortalsRequestT& request = {}) const {
    return SubmitAsync(&ApiGatewayV2Client::ListPortals, request, handler, context);
  }
 
  virtual Model::ListProductPagesOutcome ListProductPages(const Model::ListProductPagesRequest& request) const;
 
  template <typename ListProductPagesRequestT = Model::ListProductPagesRequest>
  Model::ListProductPagesOutcomeCallable ListProductPagesCallable(const ListProductPagesRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::ListProductPages, request);
  }
 
  template <typename ListProductPagesRequestT = Model::ListProductPagesRequest>
  void ListProductPagesAsync(const ListProductPagesRequestT& request, const ListProductPagesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::ListProductPages, request, handler, context);
  }
 
  virtual Model::ListProductRestEndpointPagesOutcome ListProductRestEndpointPages(
      const Model::ListProductRestEndpointPagesRequest& request) const;
 
  template <typename ListProductRestEndpointPagesRequestT = Model::ListProductRestEndpointPagesRequest>
  Model::ListProductRestEndpointPagesOutcomeCallable ListProductRestEndpointPagesCallable(
      const ListProductRestEndpointPagesRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::ListProductRestEndpointPages, request);
  }
 
  template <typename ListProductRestEndpointPagesRequestT = Model::ListProductRestEndpointPagesRequest>
  void ListProductRestEndpointPagesAsync(const ListProductRestEndpointPagesRequestT& request,
                                         const ListProductRestEndpointPagesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::ListProductRestEndpointPages, request, handler, context);
  }
 
  virtual Model::ListRoutingRulesOutcome ListRoutingRules(const Model::ListRoutingRulesRequest& request) const;
 
  template <typename ListRoutingRulesRequestT = Model::ListRoutingRulesRequest>
  Model::ListRoutingRulesOutcomeCallable ListRoutingRulesCallable(const ListRoutingRulesRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::ListRoutingRules, request);
  }
 
  template <typename ListRoutingRulesRequestT = Model::ListRoutingRulesRequest>
  void ListRoutingRulesAsync(const ListRoutingRulesRequestT& request, const ListRoutingRulesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::ListRoutingRules, request, handler, context);
  }
 
  virtual Model::PreviewPortalOutcome PreviewPortal(const Model::PreviewPortalRequest& request) const;
 
  template <typename PreviewPortalRequestT = Model::PreviewPortalRequest>
  Model::PreviewPortalOutcomeCallable PreviewPortalCallable(const PreviewPortalRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::PreviewPortal, request);
  }
 
  template <typename PreviewPortalRequestT = Model::PreviewPortalRequest>
  void PreviewPortalAsync(const PreviewPortalRequestT& request, const PreviewPortalResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::PreviewPortal, request, handler, context);
  }
 
  virtual Model::PublishPortalOutcome PublishPortal(const Model::PublishPortalRequest& request) const;
 
  template <typename PublishPortalRequestT = Model::PublishPortalRequest>
  Model::PublishPortalOutcomeCallable PublishPortalCallable(const PublishPortalRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::PublishPortal, request);
  }
 
  template <typename PublishPortalRequestT = Model::PublishPortalRequest>
  void PublishPortalAsync(const PublishPortalRequestT& request, const PublishPortalResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::PublishPortal, request, handler, context);
  }
 
  virtual Model::PutPortalProductSharingPolicyOutcome PutPortalProductSharingPolicy(
      const Model::PutPortalProductSharingPolicyRequest& request) const;
 
  template <typename PutPortalProductSharingPolicyRequestT = Model::PutPortalProductSharingPolicyRequest>
  Model::PutPortalProductSharingPolicyOutcomeCallable PutPortalProductSharingPolicyCallable(
      const PutPortalProductSharingPolicyRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::PutPortalProductSharingPolicy, request);
  }
 
  template <typename PutPortalProductSharingPolicyRequestT = Model::PutPortalProductSharingPolicyRequest>
  void PutPortalProductSharingPolicyAsync(const PutPortalProductSharingPolicyRequestT& request,
                                          const PutPortalProductSharingPolicyResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::PutPortalProductSharingPolicy, request, handler, context);
  }
 
  virtual Model::PutRoutingRuleOutcome PutRoutingRule(const Model::PutRoutingRuleRequest& request) const;
 
  template <typename PutRoutingRuleRequestT = Model::PutRoutingRuleRequest>
  Model::PutRoutingRuleOutcomeCallable PutRoutingRuleCallable(const PutRoutingRuleRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::PutRoutingRule, request);
  }
 
  template <typename PutRoutingRuleRequestT = Model::PutRoutingRuleRequest>
  void PutRoutingRuleAsync(const PutRoutingRuleRequestT& request, const PutRoutingRuleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::PutRoutingRule, request, handler, context);
  }
 
  virtual Model::ReimportApiOutcome ReimportApi(const Model::ReimportApiRequest& request) const;
 
  template <typename ReimportApiRequestT = Model::ReimportApiRequest>
  Model::ReimportApiOutcomeCallable ReimportApiCallable(const ReimportApiRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::ReimportApi, request);
  }
 
  template <typename ReimportApiRequestT = Model::ReimportApiRequest>
  void ReimportApiAsync(const ReimportApiRequestT& request, const ReimportApiResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::ReimportApi, request, handler, context);
  }
 
  virtual Model::ResetAuthorizersCacheOutcome ResetAuthorizersCache(const Model::ResetAuthorizersCacheRequest& request) const;
 
  template <typename ResetAuthorizersCacheRequestT = Model::ResetAuthorizersCacheRequest>
  Model::ResetAuthorizersCacheOutcomeCallable ResetAuthorizersCacheCallable(const ResetAuthorizersCacheRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::ResetAuthorizersCache, request);
  }
 
  template <typename ResetAuthorizersCacheRequestT = Model::ResetAuthorizersCacheRequest>
  void ResetAuthorizersCacheAsync(const ResetAuthorizersCacheRequestT& request, const ResetAuthorizersCacheResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::ResetAuthorizersCache, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::TagResource, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateApiOutcome UpdateApi(const Model::UpdateApiRequest& request) const;
 
  template <typename UpdateApiRequestT = Model::UpdateApiRequest>
  Model::UpdateApiOutcomeCallable UpdateApiCallable(const UpdateApiRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::UpdateApi, request);
  }
 
  template <typename UpdateApiRequestT = Model::UpdateApiRequest>
  void UpdateApiAsync(const UpdateApiRequestT& request, const UpdateApiResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::UpdateApi, request, handler, context);
  }
 
  virtual Model::UpdateApiMappingOutcome UpdateApiMapping(const Model::UpdateApiMappingRequest& request) const;
 
  template <typename UpdateApiMappingRequestT = Model::UpdateApiMappingRequest>
  Model::UpdateApiMappingOutcomeCallable UpdateApiMappingCallable(const UpdateApiMappingRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::UpdateApiMapping, request);
  }
 
  template <typename UpdateApiMappingRequestT = Model::UpdateApiMappingRequest>
  void UpdateApiMappingAsync(const UpdateApiMappingRequestT& request, const UpdateApiMappingResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::UpdateApiMapping, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::UpdateAuthorizer, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::UpdateDeployment, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::UpdateDomainName, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::UpdateIntegrationResponse, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::UpdateModel, request, handler, context);
  }
 
  virtual Model::UpdatePortalOutcome UpdatePortal(const Model::UpdatePortalRequest& request) const;
 
  template <typename UpdatePortalRequestT = Model::UpdatePortalRequest>
  Model::UpdatePortalOutcomeCallable UpdatePortalCallable(const UpdatePortalRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::UpdatePortal, request);
  }
 
  template <typename UpdatePortalRequestT = Model::UpdatePortalRequest>
  void UpdatePortalAsync(const UpdatePortalRequestT& request, const UpdatePortalResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::UpdatePortal, request, handler, context);
  }
 
  virtual Model::UpdatePortalProductOutcome UpdatePortalProduct(const Model::UpdatePortalProductRequest& request) const;
 
  template <typename UpdatePortalProductRequestT = Model::UpdatePortalProductRequest>
  Model::UpdatePortalProductOutcomeCallable UpdatePortalProductCallable(const UpdatePortalProductRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::UpdatePortalProduct, request);
  }
 
  template <typename UpdatePortalProductRequestT = Model::UpdatePortalProductRequest>
  void UpdatePortalProductAsync(const UpdatePortalProductRequestT& request, const UpdatePortalProductResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::UpdatePortalProduct, request, handler, context);
  }
 
  virtual Model::UpdateProductPageOutcome UpdateProductPage(const Model::UpdateProductPageRequest& request) const;
 
  template <typename UpdateProductPageRequestT = Model::UpdateProductPageRequest>
  Model::UpdateProductPageOutcomeCallable UpdateProductPageCallable(const UpdateProductPageRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::UpdateProductPage, request);
  }
 
  template <typename UpdateProductPageRequestT = Model::UpdateProductPageRequest>
  void UpdateProductPageAsync(const UpdateProductPageRequestT& request, const UpdateProductPageResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::UpdateProductPage, request, handler, context);
  }
 
  virtual Model::UpdateProductRestEndpointPageOutcome UpdateProductRestEndpointPage(
      const Model::UpdateProductRestEndpointPageRequest& request) const;
 
  template <typename UpdateProductRestEndpointPageRequestT = Model::UpdateProductRestEndpointPageRequest>
  Model::UpdateProductRestEndpointPageOutcomeCallable UpdateProductRestEndpointPageCallable(
      const UpdateProductRestEndpointPageRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::UpdateProductRestEndpointPage, request);
  }
 
  template <typename UpdateProductRestEndpointPageRequestT = Model::UpdateProductRestEndpointPageRequest>
  void UpdateProductRestEndpointPageAsync(const UpdateProductRestEndpointPageRequestT& request,
                                          const UpdateProductRestEndpointPageResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::UpdateProductRestEndpointPage, request, handler, context);
  }
 
  virtual Model::UpdateRouteOutcome UpdateRoute(const Model::UpdateRouteRequest& request) const;
 
  template <typename UpdateRouteRequestT = Model::UpdateRouteRequest>
  Model::UpdateRouteOutcomeCallable UpdateRouteCallable(const UpdateRouteRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::UpdateRoute, request);
  }
 
  template <typename UpdateRouteRequestT = Model::UpdateRouteRequest>
  void UpdateRouteAsync(const UpdateRouteRequestT& request, const UpdateRouteResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::UpdateRoute, request, handler, context);
  }
 
  virtual Model::UpdateRouteResponseOutcome UpdateRouteResponse(const Model::UpdateRouteResponseRequest& request) const;
 
  template <typename UpdateRouteResponseRequestT = Model::UpdateRouteResponseRequest>
  Model::UpdateRouteResponseOutcomeCallable UpdateRouteResponseCallable(const UpdateRouteResponseRequestT& request) const {
    return SubmitCallable(&ApiGatewayV2Client::UpdateRouteResponse, request);
  }
 
  template <typename UpdateRouteResponseRequestT = Model::UpdateRouteResponseRequest>
  void UpdateRouteResponseAsync(const UpdateRouteResponseRequestT& request, const UpdateRouteResponseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApiGatewayV2Client::UpdateRouteResponse, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::UpdateStage, 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(&ApiGatewayV2Client::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(&ApiGatewayV2Client::UpdateVpcLink, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ApiGatewayV2EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ApiGatewayV2Client>;
  void init(const ApiGatewayV2ClientConfiguration& clientConfiguration);
 
  ApiGatewayV2ClientConfiguration m_clientConfiguration;
  std::shared_ptr<ApiGatewayV2EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ApiGatewayV2
}  // namespace Aws