AppSyncClient.h

 
#pragma once
#include <aws/appsync/AppSyncServiceClientModel.h>
#include <aws/appsync/AppSync_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 AppSync {
class AWS_APPSYNC_API AppSyncClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AppSyncClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AppSyncClientConfiguration ClientConfigurationType;
  typedef AppSyncEndpointProvider EndpointProviderType;
 
  AppSyncClient(const Aws::AppSync::AppSyncClientConfiguration& clientConfiguration = Aws::AppSync::AppSyncClientConfiguration(),
                std::shared_ptr<AppSyncEndpointProviderBase> endpointProvider = nullptr);
 
  AppSyncClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<AppSyncEndpointProviderBase> endpointProvider = nullptr,
                const Aws::AppSync::AppSyncClientConfiguration& clientConfiguration = Aws::AppSync::AppSyncClientConfiguration());
 
  AppSyncClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<AppSyncEndpointProviderBase> endpointProvider = nullptr,
                const Aws::AppSync::AppSyncClientConfiguration& clientConfiguration = Aws::AppSync::AppSyncClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AppSyncClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AppSyncClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AppSyncClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AppSyncClient();
 
  virtual Model::AssociateApiOutcome AssociateApi(const Model::AssociateApiRequest& request) const;
 
  template <typename AssociateApiRequestT = Model::AssociateApiRequest>
  Model::AssociateApiOutcomeCallable AssociateApiCallable(const AssociateApiRequestT& request) const {
    return SubmitCallable(&AppSyncClient::AssociateApi, request);
  }
 
  template <typename AssociateApiRequestT = Model::AssociateApiRequest>
  void AssociateApiAsync(const AssociateApiRequestT& request, const AssociateApiResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::AssociateApi, request, handler, context);
  }
 
  virtual Model::AssociateMergedGraphqlApiOutcome AssociateMergedGraphqlApi(const Model::AssociateMergedGraphqlApiRequest& request) const;
 
  template <typename AssociateMergedGraphqlApiRequestT = Model::AssociateMergedGraphqlApiRequest>
  Model::AssociateMergedGraphqlApiOutcomeCallable AssociateMergedGraphqlApiCallable(
      const AssociateMergedGraphqlApiRequestT& request) const {
    return SubmitCallable(&AppSyncClient::AssociateMergedGraphqlApi, request);
  }
 
  template <typename AssociateMergedGraphqlApiRequestT = Model::AssociateMergedGraphqlApiRequest>
  void AssociateMergedGraphqlApiAsync(const AssociateMergedGraphqlApiRequestT& request,
                                      const AssociateMergedGraphqlApiResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::AssociateMergedGraphqlApi, request, handler, context);
  }
 
  virtual Model::AssociateSourceGraphqlApiOutcome AssociateSourceGraphqlApi(const Model::AssociateSourceGraphqlApiRequest& request) const;
 
  template <typename AssociateSourceGraphqlApiRequestT = Model::AssociateSourceGraphqlApiRequest>
  Model::AssociateSourceGraphqlApiOutcomeCallable AssociateSourceGraphqlApiCallable(
      const AssociateSourceGraphqlApiRequestT& request) const {
    return SubmitCallable(&AppSyncClient::AssociateSourceGraphqlApi, request);
  }
 
  template <typename AssociateSourceGraphqlApiRequestT = Model::AssociateSourceGraphqlApiRequest>
  void AssociateSourceGraphqlApiAsync(const AssociateSourceGraphqlApiRequestT& request,
                                      const AssociateSourceGraphqlApiResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::AssociateSourceGraphqlApi, request, handler, context);
  }
 
  virtual Model::CreateApiOutcome CreateApi(const Model::CreateApiRequest& request) const;
 
  template <typename CreateApiRequestT = Model::CreateApiRequest>
  Model::CreateApiOutcomeCallable CreateApiCallable(const CreateApiRequestT& request) const {
    return SubmitCallable(&AppSyncClient::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(&AppSyncClient::CreateApi, request, handler, context);
  }
 
  virtual Model::CreateApiCacheOutcome CreateApiCache(const Model::CreateApiCacheRequest& request) const;
 
  template <typename CreateApiCacheRequestT = Model::CreateApiCacheRequest>
  Model::CreateApiCacheOutcomeCallable CreateApiCacheCallable(const CreateApiCacheRequestT& request) const {
    return SubmitCallable(&AppSyncClient::CreateApiCache, request);
  }
 
  template <typename CreateApiCacheRequestT = Model::CreateApiCacheRequest>
  void CreateApiCacheAsync(const CreateApiCacheRequestT& request, const CreateApiCacheResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::CreateApiCache, request, handler, context);
  }
 
  virtual Model::CreateApiKeyOutcome CreateApiKey(const Model::CreateApiKeyRequest& request) const;
 
  template <typename CreateApiKeyRequestT = Model::CreateApiKeyRequest>
  Model::CreateApiKeyOutcomeCallable CreateApiKeyCallable(const CreateApiKeyRequestT& request) const {
    return SubmitCallable(&AppSyncClient::CreateApiKey, request);
  }
 
  template <typename CreateApiKeyRequestT = Model::CreateApiKeyRequest>
  void CreateApiKeyAsync(const CreateApiKeyRequestT& request, const CreateApiKeyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::CreateApiKey, request, handler, context);
  }
 
  virtual Model::CreateChannelNamespaceOutcome CreateChannelNamespace(const Model::CreateChannelNamespaceRequest& request) const;
 
  template <typename CreateChannelNamespaceRequestT = Model::CreateChannelNamespaceRequest>
  Model::CreateChannelNamespaceOutcomeCallable CreateChannelNamespaceCallable(const CreateChannelNamespaceRequestT& request) const {
    return SubmitCallable(&AppSyncClient::CreateChannelNamespace, request);
  }
 
  template <typename CreateChannelNamespaceRequestT = Model::CreateChannelNamespaceRequest>
  void CreateChannelNamespaceAsync(const CreateChannelNamespaceRequestT& request,
                                   const CreateChannelNamespaceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::CreateChannelNamespace, request, handler, context);
  }
 
  virtual Model::CreateDataSourceOutcome CreateDataSource(const Model::CreateDataSourceRequest& request) const;
 
  template <typename CreateDataSourceRequestT = Model::CreateDataSourceRequest>
  Model::CreateDataSourceOutcomeCallable CreateDataSourceCallable(const CreateDataSourceRequestT& request) const {
    return SubmitCallable(&AppSyncClient::CreateDataSource, request);
  }
 
  template <typename CreateDataSourceRequestT = Model::CreateDataSourceRequest>
  void CreateDataSourceAsync(const CreateDataSourceRequestT& request, const CreateDataSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::CreateDataSource, 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(&AppSyncClient::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(&AppSyncClient::CreateDomainName, request, handler, context);
  }
 
  virtual Model::CreateFunctionOutcome CreateFunction(const Model::CreateFunctionRequest& request) const;
 
  template <typename CreateFunctionRequestT = Model::CreateFunctionRequest>
  Model::CreateFunctionOutcomeCallable CreateFunctionCallable(const CreateFunctionRequestT& request) const {
    return SubmitCallable(&AppSyncClient::CreateFunction, request);
  }
 
  template <typename CreateFunctionRequestT = Model::CreateFunctionRequest>
  void CreateFunctionAsync(const CreateFunctionRequestT& request, const CreateFunctionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::CreateFunction, request, handler, context);
  }
 
  virtual Model::CreateGraphqlApiOutcome CreateGraphqlApi(const Model::CreateGraphqlApiRequest& request) const;
 
  template <typename CreateGraphqlApiRequestT = Model::CreateGraphqlApiRequest>
  Model::CreateGraphqlApiOutcomeCallable CreateGraphqlApiCallable(const CreateGraphqlApiRequestT& request) const {
    return SubmitCallable(&AppSyncClient::CreateGraphqlApi, request);
  }
 
  template <typename CreateGraphqlApiRequestT = Model::CreateGraphqlApiRequest>
  void CreateGraphqlApiAsync(const CreateGraphqlApiRequestT& request, const CreateGraphqlApiResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::CreateGraphqlApi, request, handler, context);
  }
 
  virtual Model::CreateResolverOutcome CreateResolver(const Model::CreateResolverRequest& request) const;
 
  template <typename CreateResolverRequestT = Model::CreateResolverRequest>
  Model::CreateResolverOutcomeCallable CreateResolverCallable(const CreateResolverRequestT& request) const {
    return SubmitCallable(&AppSyncClient::CreateResolver, request);
  }
 
  template <typename CreateResolverRequestT = Model::CreateResolverRequest>
  void CreateResolverAsync(const CreateResolverRequestT& request, const CreateResolverResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::CreateResolver, request, handler, context);
  }
 
  virtual Model::CreateTypeOutcome CreateType(const Model::CreateTypeRequest& request) const;
 
  template <typename CreateTypeRequestT = Model::CreateTypeRequest>
  Model::CreateTypeOutcomeCallable CreateTypeCallable(const CreateTypeRequestT& request) const {
    return SubmitCallable(&AppSyncClient::CreateType, request);
  }
 
  template <typename CreateTypeRequestT = Model::CreateTypeRequest>
  void CreateTypeAsync(const CreateTypeRequestT& request, const CreateTypeResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::CreateType, 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(&AppSyncClient::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(&AppSyncClient::DeleteApi, request, handler, context);
  }
 
  virtual Model::DeleteApiCacheOutcome DeleteApiCache(const Model::DeleteApiCacheRequest& request) const;
 
  template <typename DeleteApiCacheRequestT = Model::DeleteApiCacheRequest>
  Model::DeleteApiCacheOutcomeCallable DeleteApiCacheCallable(const DeleteApiCacheRequestT& request) const {
    return SubmitCallable(&AppSyncClient::DeleteApiCache, request);
  }
 
  template <typename DeleteApiCacheRequestT = Model::DeleteApiCacheRequest>
  void DeleteApiCacheAsync(const DeleteApiCacheRequestT& request, const DeleteApiCacheResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::DeleteApiCache, 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(&AppSyncClient::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(&AppSyncClient::DeleteApiKey, request, handler, context);
  }
 
  virtual Model::DeleteChannelNamespaceOutcome DeleteChannelNamespace(const Model::DeleteChannelNamespaceRequest& request) const;
 
  template <typename DeleteChannelNamespaceRequestT = Model::DeleteChannelNamespaceRequest>
  Model::DeleteChannelNamespaceOutcomeCallable DeleteChannelNamespaceCallable(const DeleteChannelNamespaceRequestT& request) const {
    return SubmitCallable(&AppSyncClient::DeleteChannelNamespace, request);
  }
 
  template <typename DeleteChannelNamespaceRequestT = Model::DeleteChannelNamespaceRequest>
  void DeleteChannelNamespaceAsync(const DeleteChannelNamespaceRequestT& request,
                                   const DeleteChannelNamespaceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::DeleteChannelNamespace, request, handler, context);
  }
 
  virtual Model::DeleteDataSourceOutcome DeleteDataSource(const Model::DeleteDataSourceRequest& request) const;
 
  template <typename DeleteDataSourceRequestT = Model::DeleteDataSourceRequest>
  Model::DeleteDataSourceOutcomeCallable DeleteDataSourceCallable(const DeleteDataSourceRequestT& request) const {
    return SubmitCallable(&AppSyncClient::DeleteDataSource, request);
  }
 
  template <typename DeleteDataSourceRequestT = Model::DeleteDataSourceRequest>
  void DeleteDataSourceAsync(const DeleteDataSourceRequestT& request, const DeleteDataSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::DeleteDataSource, 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(&AppSyncClient::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(&AppSyncClient::DeleteDomainName, request, handler, context);
  }
 
  virtual Model::DeleteFunctionOutcome DeleteFunction(const Model::DeleteFunctionRequest& request) const;
 
  template <typename DeleteFunctionRequestT = Model::DeleteFunctionRequest>
  Model::DeleteFunctionOutcomeCallable DeleteFunctionCallable(const DeleteFunctionRequestT& request) const {
    return SubmitCallable(&AppSyncClient::DeleteFunction, request);
  }
 
  template <typename DeleteFunctionRequestT = Model::DeleteFunctionRequest>
  void DeleteFunctionAsync(const DeleteFunctionRequestT& request, const DeleteFunctionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::DeleteFunction, request, handler, context);
  }
 
  virtual Model::DeleteGraphqlApiOutcome DeleteGraphqlApi(const Model::DeleteGraphqlApiRequest& request) const;
 
  template <typename DeleteGraphqlApiRequestT = Model::DeleteGraphqlApiRequest>
  Model::DeleteGraphqlApiOutcomeCallable DeleteGraphqlApiCallable(const DeleteGraphqlApiRequestT& request) const {
    return SubmitCallable(&AppSyncClient::DeleteGraphqlApi, request);
  }
 
  template <typename DeleteGraphqlApiRequestT = Model::DeleteGraphqlApiRequest>
  void DeleteGraphqlApiAsync(const DeleteGraphqlApiRequestT& request, const DeleteGraphqlApiResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::DeleteGraphqlApi, request, handler, context);
  }
 
  virtual Model::DeleteResolverOutcome DeleteResolver(const Model::DeleteResolverRequest& request) const;
 
  template <typename DeleteResolverRequestT = Model::DeleteResolverRequest>
  Model::DeleteResolverOutcomeCallable DeleteResolverCallable(const DeleteResolverRequestT& request) const {
    return SubmitCallable(&AppSyncClient::DeleteResolver, request);
  }
 
  template <typename DeleteResolverRequestT = Model::DeleteResolverRequest>
  void DeleteResolverAsync(const DeleteResolverRequestT& request, const DeleteResolverResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::DeleteResolver, request, handler, context);
  }
 
  virtual Model::DeleteTypeOutcome DeleteType(const Model::DeleteTypeRequest& request) const;
 
  template <typename DeleteTypeRequestT = Model::DeleteTypeRequest>
  Model::DeleteTypeOutcomeCallable DeleteTypeCallable(const DeleteTypeRequestT& request) const {
    return SubmitCallable(&AppSyncClient::DeleteType, request);
  }
 
  template <typename DeleteTypeRequestT = Model::DeleteTypeRequest>
  void DeleteTypeAsync(const DeleteTypeRequestT& request, const DeleteTypeResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::DeleteType, request, handler, context);
  }
 
  virtual Model::DisassociateApiOutcome DisassociateApi(const Model::DisassociateApiRequest& request) const;
 
  template <typename DisassociateApiRequestT = Model::DisassociateApiRequest>
  Model::DisassociateApiOutcomeCallable DisassociateApiCallable(const DisassociateApiRequestT& request) const {
    return SubmitCallable(&AppSyncClient::DisassociateApi, request);
  }
 
  template <typename DisassociateApiRequestT = Model::DisassociateApiRequest>
  void DisassociateApiAsync(const DisassociateApiRequestT& request, const DisassociateApiResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::DisassociateApi, request, handler, context);
  }
 
  virtual Model::DisassociateMergedGraphqlApiOutcome DisassociateMergedGraphqlApi(
      const Model::DisassociateMergedGraphqlApiRequest& request) const;
 
  template <typename DisassociateMergedGraphqlApiRequestT = Model::DisassociateMergedGraphqlApiRequest>
  Model::DisassociateMergedGraphqlApiOutcomeCallable DisassociateMergedGraphqlApiCallable(
      const DisassociateMergedGraphqlApiRequestT& request) const {
    return SubmitCallable(&AppSyncClient::DisassociateMergedGraphqlApi, request);
  }
 
  template <typename DisassociateMergedGraphqlApiRequestT = Model::DisassociateMergedGraphqlApiRequest>
  void DisassociateMergedGraphqlApiAsync(const DisassociateMergedGraphqlApiRequestT& request,
                                         const DisassociateMergedGraphqlApiResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::DisassociateMergedGraphqlApi, request, handler, context);
  }
 
  virtual Model::DisassociateSourceGraphqlApiOutcome DisassociateSourceGraphqlApi(
      const Model::DisassociateSourceGraphqlApiRequest& request) const;
 
  template <typename DisassociateSourceGraphqlApiRequestT = Model::DisassociateSourceGraphqlApiRequest>
  Model::DisassociateSourceGraphqlApiOutcomeCallable DisassociateSourceGraphqlApiCallable(
      const DisassociateSourceGraphqlApiRequestT& request) const {
    return SubmitCallable(&AppSyncClient::DisassociateSourceGraphqlApi, request);
  }
 
  template <typename DisassociateSourceGraphqlApiRequestT = Model::DisassociateSourceGraphqlApiRequest>
  void DisassociateSourceGraphqlApiAsync(const DisassociateSourceGraphqlApiRequestT& request,
                                         const DisassociateSourceGraphqlApiResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::DisassociateSourceGraphqlApi, request, handler, context);
  }
 
  virtual Model::EvaluateCodeOutcome EvaluateCode(const Model::EvaluateCodeRequest& request) const;
 
  template <typename EvaluateCodeRequestT = Model::EvaluateCodeRequest>
  Model::EvaluateCodeOutcomeCallable EvaluateCodeCallable(const EvaluateCodeRequestT& request) const {
    return SubmitCallable(&AppSyncClient::EvaluateCode, request);
  }
 
  template <typename EvaluateCodeRequestT = Model::EvaluateCodeRequest>
  void EvaluateCodeAsync(const EvaluateCodeRequestT& request, const EvaluateCodeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::EvaluateCode, request, handler, context);
  }
 
  virtual Model::EvaluateMappingTemplateOutcome EvaluateMappingTemplate(const Model::EvaluateMappingTemplateRequest& request) const;
 
  template <typename EvaluateMappingTemplateRequestT = Model::EvaluateMappingTemplateRequest>
  Model::EvaluateMappingTemplateOutcomeCallable EvaluateMappingTemplateCallable(const EvaluateMappingTemplateRequestT& request) const {
    return SubmitCallable(&AppSyncClient::EvaluateMappingTemplate, request);
  }
 
  template <typename EvaluateMappingTemplateRequestT = Model::EvaluateMappingTemplateRequest>
  void EvaluateMappingTemplateAsync(const EvaluateMappingTemplateRequestT& request,
                                    const EvaluateMappingTemplateResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::EvaluateMappingTemplate, request, handler, context);
  }
 
  virtual Model::FlushApiCacheOutcome FlushApiCache(const Model::FlushApiCacheRequest& request) const;
 
  template <typename FlushApiCacheRequestT = Model::FlushApiCacheRequest>
  Model::FlushApiCacheOutcomeCallable FlushApiCacheCallable(const FlushApiCacheRequestT& request) const {
    return SubmitCallable(&AppSyncClient::FlushApiCache, request);
  }
 
  template <typename FlushApiCacheRequestT = Model::FlushApiCacheRequest>
  void FlushApiCacheAsync(const FlushApiCacheRequestT& request, const FlushApiCacheResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::FlushApiCache, 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(&AppSyncClient::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(&AppSyncClient::GetApi, request, handler, context);
  }
 
  virtual Model::GetApiAssociationOutcome GetApiAssociation(const Model::GetApiAssociationRequest& request) const;
 
  template <typename GetApiAssociationRequestT = Model::GetApiAssociationRequest>
  Model::GetApiAssociationOutcomeCallable GetApiAssociationCallable(const GetApiAssociationRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetApiAssociation, request);
  }
 
  template <typename GetApiAssociationRequestT = Model::GetApiAssociationRequest>
  void GetApiAssociationAsync(const GetApiAssociationRequestT& request, const GetApiAssociationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetApiAssociation, request, handler, context);
  }
 
  virtual Model::GetApiCacheOutcome GetApiCache(const Model::GetApiCacheRequest& request) const;
 
  template <typename GetApiCacheRequestT = Model::GetApiCacheRequest>
  Model::GetApiCacheOutcomeCallable GetApiCacheCallable(const GetApiCacheRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetApiCache, request);
  }
 
  template <typename GetApiCacheRequestT = Model::GetApiCacheRequest>
  void GetApiCacheAsync(const GetApiCacheRequestT& request, const GetApiCacheResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetApiCache, request, handler, context);
  }
 
  virtual Model::GetChannelNamespaceOutcome GetChannelNamespace(const Model::GetChannelNamespaceRequest& request) const;
 
  template <typename GetChannelNamespaceRequestT = Model::GetChannelNamespaceRequest>
  Model::GetChannelNamespaceOutcomeCallable GetChannelNamespaceCallable(const GetChannelNamespaceRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetChannelNamespace, request);
  }
 
  template <typename GetChannelNamespaceRequestT = Model::GetChannelNamespaceRequest>
  void GetChannelNamespaceAsync(const GetChannelNamespaceRequestT& request, const GetChannelNamespaceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetChannelNamespace, request, handler, context);
  }
 
  virtual Model::GetDataSourceOutcome GetDataSource(const Model::GetDataSourceRequest& request) const;
 
  template <typename GetDataSourceRequestT = Model::GetDataSourceRequest>
  Model::GetDataSourceOutcomeCallable GetDataSourceCallable(const GetDataSourceRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetDataSource, request);
  }
 
  template <typename GetDataSourceRequestT = Model::GetDataSourceRequest>
  void GetDataSourceAsync(const GetDataSourceRequestT& request, const GetDataSourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetDataSource, request, handler, context);
  }
 
  virtual Model::GetDataSourceIntrospectionOutcome GetDataSourceIntrospection(
      const Model::GetDataSourceIntrospectionRequest& request) const;
 
  template <typename GetDataSourceIntrospectionRequestT = Model::GetDataSourceIntrospectionRequest>
  Model::GetDataSourceIntrospectionOutcomeCallable GetDataSourceIntrospectionCallable(
      const GetDataSourceIntrospectionRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetDataSourceIntrospection, request);
  }
 
  template <typename GetDataSourceIntrospectionRequestT = Model::GetDataSourceIntrospectionRequest>
  void GetDataSourceIntrospectionAsync(const GetDataSourceIntrospectionRequestT& request,
                                       const GetDataSourceIntrospectionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetDataSourceIntrospection, 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(&AppSyncClient::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(&AppSyncClient::GetDomainName, request, handler, context);
  }
 
  virtual Model::GetFunctionOutcome GetFunction(const Model::GetFunctionRequest& request) const;
 
  template <typename GetFunctionRequestT = Model::GetFunctionRequest>
  Model::GetFunctionOutcomeCallable GetFunctionCallable(const GetFunctionRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetFunction, request);
  }
 
  template <typename GetFunctionRequestT = Model::GetFunctionRequest>
  void GetFunctionAsync(const GetFunctionRequestT& request, const GetFunctionResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetFunction, request, handler, context);
  }
 
  virtual Model::GetGraphqlApiOutcome GetGraphqlApi(const Model::GetGraphqlApiRequest& request) const;
 
  template <typename GetGraphqlApiRequestT = Model::GetGraphqlApiRequest>
  Model::GetGraphqlApiOutcomeCallable GetGraphqlApiCallable(const GetGraphqlApiRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetGraphqlApi, request);
  }
 
  template <typename GetGraphqlApiRequestT = Model::GetGraphqlApiRequest>
  void GetGraphqlApiAsync(const GetGraphqlApiRequestT& request, const GetGraphqlApiResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetGraphqlApi, request, handler, context);
  }
 
  virtual Model::GetGraphqlApiEnvironmentVariablesOutcome GetGraphqlApiEnvironmentVariables(
      const Model::GetGraphqlApiEnvironmentVariablesRequest& request) const;
 
  template <typename GetGraphqlApiEnvironmentVariablesRequestT = Model::GetGraphqlApiEnvironmentVariablesRequest>
  Model::GetGraphqlApiEnvironmentVariablesOutcomeCallable GetGraphqlApiEnvironmentVariablesCallable(
      const GetGraphqlApiEnvironmentVariablesRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetGraphqlApiEnvironmentVariables, request);
  }
 
  template <typename GetGraphqlApiEnvironmentVariablesRequestT = Model::GetGraphqlApiEnvironmentVariablesRequest>
  void GetGraphqlApiEnvironmentVariablesAsync(const GetGraphqlApiEnvironmentVariablesRequestT& request,
                                              const GetGraphqlApiEnvironmentVariablesResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetGraphqlApiEnvironmentVariables, request, handler, context);
  }
 
  virtual Model::GetIntrospectionSchemaOutcome GetIntrospectionSchema(const Model::GetIntrospectionSchemaRequest& request) const;
 
  template <typename GetIntrospectionSchemaRequestT = Model::GetIntrospectionSchemaRequest>
  Model::GetIntrospectionSchemaOutcomeCallable GetIntrospectionSchemaCallable(const GetIntrospectionSchemaRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetIntrospectionSchema, request);
  }
 
  template <typename GetIntrospectionSchemaRequestT = Model::GetIntrospectionSchemaRequest>
  void GetIntrospectionSchemaAsync(const GetIntrospectionSchemaRequestT& request,
                                   const GetIntrospectionSchemaResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetIntrospectionSchema, request, handler, context);
  }
 
  virtual Model::GetResolverOutcome GetResolver(const Model::GetResolverRequest& request) const;
 
  template <typename GetResolverRequestT = Model::GetResolverRequest>
  Model::GetResolverOutcomeCallable GetResolverCallable(const GetResolverRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetResolver, request);
  }
 
  template <typename GetResolverRequestT = Model::GetResolverRequest>
  void GetResolverAsync(const GetResolverRequestT& request, const GetResolverResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetResolver, request, handler, context);
  }
 
  virtual Model::GetSchemaCreationStatusOutcome GetSchemaCreationStatus(const Model::GetSchemaCreationStatusRequest& request) const;
 
  template <typename GetSchemaCreationStatusRequestT = Model::GetSchemaCreationStatusRequest>
  Model::GetSchemaCreationStatusOutcomeCallable GetSchemaCreationStatusCallable(const GetSchemaCreationStatusRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetSchemaCreationStatus, request);
  }
 
  template <typename GetSchemaCreationStatusRequestT = Model::GetSchemaCreationStatusRequest>
  void GetSchemaCreationStatusAsync(const GetSchemaCreationStatusRequestT& request,
                                    const GetSchemaCreationStatusResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetSchemaCreationStatus, request, handler, context);
  }
 
  virtual Model::GetSourceApiAssociationOutcome GetSourceApiAssociation(const Model::GetSourceApiAssociationRequest& request) const;
 
  template <typename GetSourceApiAssociationRequestT = Model::GetSourceApiAssociationRequest>
  Model::GetSourceApiAssociationOutcomeCallable GetSourceApiAssociationCallable(const GetSourceApiAssociationRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetSourceApiAssociation, request);
  }
 
  template <typename GetSourceApiAssociationRequestT = Model::GetSourceApiAssociationRequest>
  void GetSourceApiAssociationAsync(const GetSourceApiAssociationRequestT& request,
                                    const GetSourceApiAssociationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetSourceApiAssociation, request, handler, context);
  }
 
  virtual Model::GetTypeOutcome GetType(const Model::GetTypeRequest& request) const;
 
  template <typename GetTypeRequestT = Model::GetTypeRequest>
  Model::GetTypeOutcomeCallable GetTypeCallable(const GetTypeRequestT& request) const {
    return SubmitCallable(&AppSyncClient::GetType, request);
  }
 
  template <typename GetTypeRequestT = Model::GetTypeRequest>
  void GetTypeAsync(const GetTypeRequestT& request, const GetTypeResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::GetType, request, handler, context);
  }
 
  virtual Model::ListApiKeysOutcome ListApiKeys(const Model::ListApiKeysRequest& request) const;
 
  template <typename ListApiKeysRequestT = Model::ListApiKeysRequest>
  Model::ListApiKeysOutcomeCallable ListApiKeysCallable(const ListApiKeysRequestT& request) const {
    return SubmitCallable(&AppSyncClient::ListApiKeys, request);
  }
 
  template <typename ListApiKeysRequestT = Model::ListApiKeysRequest>
  void ListApiKeysAsync(const ListApiKeysRequestT& request, const ListApiKeysResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::ListApiKeys, request, handler, context);
  }
 
  virtual Model::ListApisOutcome ListApis(const Model::ListApisRequest& request = {}) const;
 
  template <typename ListApisRequestT = Model::ListApisRequest>
  Model::ListApisOutcomeCallable ListApisCallable(const ListApisRequestT& request = {}) const {
    return SubmitCallable(&AppSyncClient::ListApis, request);
  }
 
  template <typename ListApisRequestT = Model::ListApisRequest>
  void ListApisAsync(const ListApisResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListApisRequestT& request = {}) const {
    return SubmitAsync(&AppSyncClient::ListApis, request, handler, context);
  }
 
  virtual Model::ListChannelNamespacesOutcome ListChannelNamespaces(const Model::ListChannelNamespacesRequest& request) const;
 
  template <typename ListChannelNamespacesRequestT = Model::ListChannelNamespacesRequest>
  Model::ListChannelNamespacesOutcomeCallable ListChannelNamespacesCallable(const ListChannelNamespacesRequestT& request) const {
    return SubmitCallable(&AppSyncClient::ListChannelNamespaces, request);
  }
 
  template <typename ListChannelNamespacesRequestT = Model::ListChannelNamespacesRequest>
  void ListChannelNamespacesAsync(const ListChannelNamespacesRequestT& request, const ListChannelNamespacesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::ListChannelNamespaces, request, handler, context);
  }
 
  virtual Model::ListDataSourcesOutcome ListDataSources(const Model::ListDataSourcesRequest& request) const;
 
  template <typename ListDataSourcesRequestT = Model::ListDataSourcesRequest>
  Model::ListDataSourcesOutcomeCallable ListDataSourcesCallable(const ListDataSourcesRequestT& request) const {
    return SubmitCallable(&AppSyncClient::ListDataSources, request);
  }
 
  template <typename ListDataSourcesRequestT = Model::ListDataSourcesRequest>
  void ListDataSourcesAsync(const ListDataSourcesRequestT& request, const ListDataSourcesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::ListDataSources, request, handler, context);
  }
 
  virtual Model::ListDomainNamesOutcome ListDomainNames(const Model::ListDomainNamesRequest& request = {}) const;
 
  template <typename ListDomainNamesRequestT = Model::ListDomainNamesRequest>
  Model::ListDomainNamesOutcomeCallable ListDomainNamesCallable(const ListDomainNamesRequestT& request = {}) const {
    return SubmitCallable(&AppSyncClient::ListDomainNames, request);
  }
 
  template <typename ListDomainNamesRequestT = Model::ListDomainNamesRequest>
  void ListDomainNamesAsync(const ListDomainNamesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListDomainNamesRequestT& request = {}) const {
    return SubmitAsync(&AppSyncClient::ListDomainNames, request, handler, context);
  }
 
  virtual Model::ListFunctionsOutcome ListFunctions(const Model::ListFunctionsRequest& request) const;
 
  template <typename ListFunctionsRequestT = Model::ListFunctionsRequest>
  Model::ListFunctionsOutcomeCallable ListFunctionsCallable(const ListFunctionsRequestT& request) const {
    return SubmitCallable(&AppSyncClient::ListFunctions, request);
  }
 
  template <typename ListFunctionsRequestT = Model::ListFunctionsRequest>
  void ListFunctionsAsync(const ListFunctionsRequestT& request, const ListFunctionsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::ListFunctions, request, handler, context);
  }
 
  virtual Model::ListGraphqlApisOutcome ListGraphqlApis(const Model::ListGraphqlApisRequest& request = {}) const;
 
  template <typename ListGraphqlApisRequestT = Model::ListGraphqlApisRequest>
  Model::ListGraphqlApisOutcomeCallable ListGraphqlApisCallable(const ListGraphqlApisRequestT& request = {}) const {
    return SubmitCallable(&AppSyncClient::ListGraphqlApis, request);
  }
 
  template <typename ListGraphqlApisRequestT = Model::ListGraphqlApisRequest>
  void ListGraphqlApisAsync(const ListGraphqlApisResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListGraphqlApisRequestT& request = {}) const {
    return SubmitAsync(&AppSyncClient::ListGraphqlApis, request, handler, context);
  }
 
  virtual Model::ListResolversOutcome ListResolvers(const Model::ListResolversRequest& request) const;
 
  template <typename ListResolversRequestT = Model::ListResolversRequest>
  Model::ListResolversOutcomeCallable ListResolversCallable(const ListResolversRequestT& request) const {
    return SubmitCallable(&AppSyncClient::ListResolvers, request);
  }
 
  template <typename ListResolversRequestT = Model::ListResolversRequest>
  void ListResolversAsync(const ListResolversRequestT& request, const ListResolversResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::ListResolvers, request, handler, context);
  }
 
  virtual Model::ListResolversByFunctionOutcome ListResolversByFunction(const Model::ListResolversByFunctionRequest& request) const;
 
  template <typename ListResolversByFunctionRequestT = Model::ListResolversByFunctionRequest>
  Model::ListResolversByFunctionOutcomeCallable ListResolversByFunctionCallable(const ListResolversByFunctionRequestT& request) const {
    return SubmitCallable(&AppSyncClient::ListResolversByFunction, request);
  }
 
  template <typename ListResolversByFunctionRequestT = Model::ListResolversByFunctionRequest>
  void ListResolversByFunctionAsync(const ListResolversByFunctionRequestT& request,
                                    const ListResolversByFunctionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::ListResolversByFunction, request, handler, context);
  }
 
  virtual Model::ListSourceApiAssociationsOutcome ListSourceApiAssociations(const Model::ListSourceApiAssociationsRequest& request) const;
 
  template <typename ListSourceApiAssociationsRequestT = Model::ListSourceApiAssociationsRequest>
  Model::ListSourceApiAssociationsOutcomeCallable ListSourceApiAssociationsCallable(
      const ListSourceApiAssociationsRequestT& request) const {
    return SubmitCallable(&AppSyncClient::ListSourceApiAssociations, request);
  }
 
  template <typename ListSourceApiAssociationsRequestT = Model::ListSourceApiAssociationsRequest>
  void ListSourceApiAssociationsAsync(const ListSourceApiAssociationsRequestT& request,
                                      const ListSourceApiAssociationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::ListSourceApiAssociations, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&AppSyncClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTypesOutcome ListTypes(const Model::ListTypesRequest& request) const;
 
  template <typename ListTypesRequestT = Model::ListTypesRequest>
  Model::ListTypesOutcomeCallable ListTypesCallable(const ListTypesRequestT& request) const {
    return SubmitCallable(&AppSyncClient::ListTypes, request);
  }
 
  template <typename ListTypesRequestT = Model::ListTypesRequest>
  void ListTypesAsync(const ListTypesRequestT& request, const ListTypesResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::ListTypes, request, handler, context);
  }
 
  virtual Model::ListTypesByAssociationOutcome ListTypesByAssociation(const Model::ListTypesByAssociationRequest& request) const;
 
  template <typename ListTypesByAssociationRequestT = Model::ListTypesByAssociationRequest>
  Model::ListTypesByAssociationOutcomeCallable ListTypesByAssociationCallable(const ListTypesByAssociationRequestT& request) const {
    return SubmitCallable(&AppSyncClient::ListTypesByAssociation, request);
  }
 
  template <typename ListTypesByAssociationRequestT = Model::ListTypesByAssociationRequest>
  void ListTypesByAssociationAsync(const ListTypesByAssociationRequestT& request,
                                   const ListTypesByAssociationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::ListTypesByAssociation, request, handler, context);
  }
 
  virtual Model::PutGraphqlApiEnvironmentVariablesOutcome PutGraphqlApiEnvironmentVariables(
      const Model::PutGraphqlApiEnvironmentVariablesRequest& request) const;
 
  template <typename PutGraphqlApiEnvironmentVariablesRequestT = Model::PutGraphqlApiEnvironmentVariablesRequest>
  Model::PutGraphqlApiEnvironmentVariablesOutcomeCallable PutGraphqlApiEnvironmentVariablesCallable(
      const PutGraphqlApiEnvironmentVariablesRequestT& request) const {
    return SubmitCallable(&AppSyncClient::PutGraphqlApiEnvironmentVariables, request);
  }
 
  template <typename PutGraphqlApiEnvironmentVariablesRequestT = Model::PutGraphqlApiEnvironmentVariablesRequest>
  void PutGraphqlApiEnvironmentVariablesAsync(const PutGraphqlApiEnvironmentVariablesRequestT& request,
                                              const PutGraphqlApiEnvironmentVariablesResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::PutGraphqlApiEnvironmentVariables, request, handler, context);
  }
 
  virtual Model::StartDataSourceIntrospectionOutcome StartDataSourceIntrospection(
      const Model::StartDataSourceIntrospectionRequest& request = {}) const;
 
  template <typename StartDataSourceIntrospectionRequestT = Model::StartDataSourceIntrospectionRequest>
  Model::StartDataSourceIntrospectionOutcomeCallable StartDataSourceIntrospectionCallable(
      const StartDataSourceIntrospectionRequestT& request = {}) const {
    return SubmitCallable(&AppSyncClient::StartDataSourceIntrospection, request);
  }
 
  template <typename StartDataSourceIntrospectionRequestT = Model::StartDataSourceIntrospectionRequest>
  void StartDataSourceIntrospectionAsync(const StartDataSourceIntrospectionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const StartDataSourceIntrospectionRequestT& request = {}) const {
    return SubmitAsync(&AppSyncClient::StartDataSourceIntrospection, request, handler, context);
  }
 
  virtual Model::StartSchemaCreationOutcome StartSchemaCreation(const Model::StartSchemaCreationRequest& request) const;
 
  template <typename StartSchemaCreationRequestT = Model::StartSchemaCreationRequest>
  Model::StartSchemaCreationOutcomeCallable StartSchemaCreationCallable(const StartSchemaCreationRequestT& request) const {
    return SubmitCallable(&AppSyncClient::StartSchemaCreation, request);
  }
 
  template <typename StartSchemaCreationRequestT = Model::StartSchemaCreationRequest>
  void StartSchemaCreationAsync(const StartSchemaCreationRequestT& request, const StartSchemaCreationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::StartSchemaCreation, request, handler, context);
  }
 
  virtual Model::StartSchemaMergeOutcome StartSchemaMerge(const Model::StartSchemaMergeRequest& request) const;
 
  template <typename StartSchemaMergeRequestT = Model::StartSchemaMergeRequest>
  Model::StartSchemaMergeOutcomeCallable StartSchemaMergeCallable(const StartSchemaMergeRequestT& request) const {
    return SubmitCallable(&AppSyncClient::StartSchemaMerge, request);
  }
 
  template <typename StartSchemaMergeRequestT = Model::StartSchemaMergeRequest>
  void StartSchemaMergeAsync(const StartSchemaMergeRequestT& request, const StartSchemaMergeResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::StartSchemaMerge, 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(&AppSyncClient::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(&AppSyncClient::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(&AppSyncClient::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(&AppSyncClient::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(&AppSyncClient::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(&AppSyncClient::UpdateApi, request, handler, context);
  }
 
  virtual Model::UpdateApiCacheOutcome UpdateApiCache(const Model::UpdateApiCacheRequest& request) const;
 
  template <typename UpdateApiCacheRequestT = Model::UpdateApiCacheRequest>
  Model::UpdateApiCacheOutcomeCallable UpdateApiCacheCallable(const UpdateApiCacheRequestT& request) const {
    return SubmitCallable(&AppSyncClient::UpdateApiCache, request);
  }
 
  template <typename UpdateApiCacheRequestT = Model::UpdateApiCacheRequest>
  void UpdateApiCacheAsync(const UpdateApiCacheRequestT& request, const UpdateApiCacheResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::UpdateApiCache, 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(&AppSyncClient::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(&AppSyncClient::UpdateApiKey, request, handler, context);
  }
 
  virtual Model::UpdateChannelNamespaceOutcome UpdateChannelNamespace(const Model::UpdateChannelNamespaceRequest& request) const;
 
  template <typename UpdateChannelNamespaceRequestT = Model::UpdateChannelNamespaceRequest>
  Model::UpdateChannelNamespaceOutcomeCallable UpdateChannelNamespaceCallable(const UpdateChannelNamespaceRequestT& request) const {
    return SubmitCallable(&AppSyncClient::UpdateChannelNamespace, request);
  }
 
  template <typename UpdateChannelNamespaceRequestT = Model::UpdateChannelNamespaceRequest>
  void UpdateChannelNamespaceAsync(const UpdateChannelNamespaceRequestT& request,
                                   const UpdateChannelNamespaceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::UpdateChannelNamespace, request, handler, context);
  }
 
  virtual Model::UpdateDataSourceOutcome UpdateDataSource(const Model::UpdateDataSourceRequest& request) const;
 
  template <typename UpdateDataSourceRequestT = Model::UpdateDataSourceRequest>
  Model::UpdateDataSourceOutcomeCallable UpdateDataSourceCallable(const UpdateDataSourceRequestT& request) const {
    return SubmitCallable(&AppSyncClient::UpdateDataSource, request);
  }
 
  template <typename UpdateDataSourceRequestT = Model::UpdateDataSourceRequest>
  void UpdateDataSourceAsync(const UpdateDataSourceRequestT& request, const UpdateDataSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::UpdateDataSource, 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(&AppSyncClient::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(&AppSyncClient::UpdateDomainName, request, handler, context);
  }
 
  virtual Model::UpdateFunctionOutcome UpdateFunction(const Model::UpdateFunctionRequest& request) const;
 
  template <typename UpdateFunctionRequestT = Model::UpdateFunctionRequest>
  Model::UpdateFunctionOutcomeCallable UpdateFunctionCallable(const UpdateFunctionRequestT& request) const {
    return SubmitCallable(&AppSyncClient::UpdateFunction, request);
  }
 
  template <typename UpdateFunctionRequestT = Model::UpdateFunctionRequest>
  void UpdateFunctionAsync(const UpdateFunctionRequestT& request, const UpdateFunctionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::UpdateFunction, request, handler, context);
  }
 
  virtual Model::UpdateGraphqlApiOutcome UpdateGraphqlApi(const Model::UpdateGraphqlApiRequest& request) const;
 
  template <typename UpdateGraphqlApiRequestT = Model::UpdateGraphqlApiRequest>
  Model::UpdateGraphqlApiOutcomeCallable UpdateGraphqlApiCallable(const UpdateGraphqlApiRequestT& request) const {
    return SubmitCallable(&AppSyncClient::UpdateGraphqlApi, request);
  }
 
  template <typename UpdateGraphqlApiRequestT = Model::UpdateGraphqlApiRequest>
  void UpdateGraphqlApiAsync(const UpdateGraphqlApiRequestT& request, const UpdateGraphqlApiResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::UpdateGraphqlApi, request, handler, context);
  }
 
  virtual Model::UpdateResolverOutcome UpdateResolver(const Model::UpdateResolverRequest& request) const;
 
  template <typename UpdateResolverRequestT = Model::UpdateResolverRequest>
  Model::UpdateResolverOutcomeCallable UpdateResolverCallable(const UpdateResolverRequestT& request) const {
    return SubmitCallable(&AppSyncClient::UpdateResolver, request);
  }
 
  template <typename UpdateResolverRequestT = Model::UpdateResolverRequest>
  void UpdateResolverAsync(const UpdateResolverRequestT& request, const UpdateResolverResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::UpdateResolver, request, handler, context);
  }
 
  virtual Model::UpdateSourceApiAssociationOutcome UpdateSourceApiAssociation(
      const Model::UpdateSourceApiAssociationRequest& request) const;
 
  template <typename UpdateSourceApiAssociationRequestT = Model::UpdateSourceApiAssociationRequest>
  Model::UpdateSourceApiAssociationOutcomeCallable UpdateSourceApiAssociationCallable(
      const UpdateSourceApiAssociationRequestT& request) const {
    return SubmitCallable(&AppSyncClient::UpdateSourceApiAssociation, request);
  }
 
  template <typename UpdateSourceApiAssociationRequestT = Model::UpdateSourceApiAssociationRequest>
  void UpdateSourceApiAssociationAsync(const UpdateSourceApiAssociationRequestT& request,
                                       const UpdateSourceApiAssociationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::UpdateSourceApiAssociation, request, handler, context);
  }
 
  virtual Model::UpdateTypeOutcome UpdateType(const Model::UpdateTypeRequest& request) const;
 
  template <typename UpdateTypeRequestT = Model::UpdateTypeRequest>
  Model::UpdateTypeOutcomeCallable UpdateTypeCallable(const UpdateTypeRequestT& request) const {
    return SubmitCallable(&AppSyncClient::UpdateType, request);
  }
 
  template <typename UpdateTypeRequestT = Model::UpdateTypeRequest>
  void UpdateTypeAsync(const UpdateTypeRequestT& request, const UpdateTypeResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppSyncClient::UpdateType, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<AppSyncEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AppSyncClient>;
  void init(const AppSyncClientConfiguration& clientConfiguration);
 
  AppSyncClientConfiguration m_clientConfiguration;
  std::shared_ptr<AppSyncEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AppSync
}  // namespace Aws