AppSyncClient.h

 
#pragma once
#include <aws/appsync/AppSync_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/appsync/AppSyncServiceClientModel.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