DataZoneClient.h

 
#pragma once
#include <aws/datazone/DataZone_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/datazone/DataZoneServiceClientModel.h>
 
namespace Aws
{
namespace DataZone
{
  class AWS_DATAZONE_API DataZoneClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<DataZoneClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef DataZoneClientConfiguration ClientConfigurationType;
      typedef DataZoneEndpointProvider EndpointProviderType;
 
        DataZoneClient(const Aws::DataZone::DataZoneClientConfiguration& clientConfiguration = Aws::DataZone::DataZoneClientConfiguration(),
                       std::shared_ptr<DataZoneEndpointProviderBase> endpointProvider = nullptr);
 
        DataZoneClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<DataZoneEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::DataZone::DataZoneClientConfiguration& clientConfiguration = Aws::DataZone::DataZoneClientConfiguration());
 
        DataZoneClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<DataZoneEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::DataZone::DataZoneClientConfiguration& clientConfiguration = Aws::DataZone::DataZoneClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        DataZoneClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DataZoneClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DataZoneClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~DataZoneClient();
 
        virtual Model::AcceptPredictionsOutcome AcceptPredictions(const Model::AcceptPredictionsRequest& request) const;
 
        template<typename AcceptPredictionsRequestT = Model::AcceptPredictionsRequest>
        Model::AcceptPredictionsOutcomeCallable AcceptPredictionsCallable(const AcceptPredictionsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::AcceptPredictions, request);
        }
 
        template<typename AcceptPredictionsRequestT = Model::AcceptPredictionsRequest>
        void AcceptPredictionsAsync(const AcceptPredictionsRequestT& request, const AcceptPredictionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::AcceptPredictions, request, handler, context);
        }
 
        virtual Model::AcceptSubscriptionRequestOutcome AcceptSubscriptionRequest(const Model::AcceptSubscriptionRequestRequest& request) const;
 
        template<typename AcceptSubscriptionRequestRequestT = Model::AcceptSubscriptionRequestRequest>
        Model::AcceptSubscriptionRequestOutcomeCallable AcceptSubscriptionRequestCallable(const AcceptSubscriptionRequestRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::AcceptSubscriptionRequest, request);
        }
 
        template<typename AcceptSubscriptionRequestRequestT = Model::AcceptSubscriptionRequestRequest>
        void AcceptSubscriptionRequestAsync(const AcceptSubscriptionRequestRequestT& request, const AcceptSubscriptionRequestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::AcceptSubscriptionRequest, request, handler, context);
        }
 
        virtual Model::AddEntityOwnerOutcome AddEntityOwner(const Model::AddEntityOwnerRequest& request) const;
 
        template<typename AddEntityOwnerRequestT = Model::AddEntityOwnerRequest>
        Model::AddEntityOwnerOutcomeCallable AddEntityOwnerCallable(const AddEntityOwnerRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::AddEntityOwner, request);
        }
 
        template<typename AddEntityOwnerRequestT = Model::AddEntityOwnerRequest>
        void AddEntityOwnerAsync(const AddEntityOwnerRequestT& request, const AddEntityOwnerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::AddEntityOwner, request, handler, context);
        }
 
        virtual Model::AddPolicyGrantOutcome AddPolicyGrant(const Model::AddPolicyGrantRequest& request) const;
 
        template<typename AddPolicyGrantRequestT = Model::AddPolicyGrantRequest>
        Model::AddPolicyGrantOutcomeCallable AddPolicyGrantCallable(const AddPolicyGrantRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::AddPolicyGrant, request);
        }
 
        template<typename AddPolicyGrantRequestT = Model::AddPolicyGrantRequest>
        void AddPolicyGrantAsync(const AddPolicyGrantRequestT& request, const AddPolicyGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::AddPolicyGrant, request, handler, context);
        }
 
        virtual Model::AssociateEnvironmentRoleOutcome AssociateEnvironmentRole(const Model::AssociateEnvironmentRoleRequest& request) const;
 
        template<typename AssociateEnvironmentRoleRequestT = Model::AssociateEnvironmentRoleRequest>
        Model::AssociateEnvironmentRoleOutcomeCallable AssociateEnvironmentRoleCallable(const AssociateEnvironmentRoleRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::AssociateEnvironmentRole, request);
        }
 
        template<typename AssociateEnvironmentRoleRequestT = Model::AssociateEnvironmentRoleRequest>
        void AssociateEnvironmentRoleAsync(const AssociateEnvironmentRoleRequestT& request, const AssociateEnvironmentRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::AssociateEnvironmentRole, request, handler, context);
        }
 
        virtual Model::AssociateGovernedTermsOutcome AssociateGovernedTerms(const Model::AssociateGovernedTermsRequest& request) const;
 
        template<typename AssociateGovernedTermsRequestT = Model::AssociateGovernedTermsRequest>
        Model::AssociateGovernedTermsOutcomeCallable AssociateGovernedTermsCallable(const AssociateGovernedTermsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::AssociateGovernedTerms, request);
        }
 
        template<typename AssociateGovernedTermsRequestT = Model::AssociateGovernedTermsRequest>
        void AssociateGovernedTermsAsync(const AssociateGovernedTermsRequestT& request, const AssociateGovernedTermsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::AssociateGovernedTerms, request, handler, context);
        }
 
        virtual Model::CancelMetadataGenerationRunOutcome CancelMetadataGenerationRun(const Model::CancelMetadataGenerationRunRequest& request) const;
 
        template<typename CancelMetadataGenerationRunRequestT = Model::CancelMetadataGenerationRunRequest>
        Model::CancelMetadataGenerationRunOutcomeCallable CancelMetadataGenerationRunCallable(const CancelMetadataGenerationRunRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CancelMetadataGenerationRun, request);
        }
 
        template<typename CancelMetadataGenerationRunRequestT = Model::CancelMetadataGenerationRunRequest>
        void CancelMetadataGenerationRunAsync(const CancelMetadataGenerationRunRequestT& request, const CancelMetadataGenerationRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CancelMetadataGenerationRun, request, handler, context);
        }
 
        virtual Model::CancelSubscriptionOutcome CancelSubscription(const Model::CancelSubscriptionRequest& request) const;
 
        template<typename CancelSubscriptionRequestT = Model::CancelSubscriptionRequest>
        Model::CancelSubscriptionOutcomeCallable CancelSubscriptionCallable(const CancelSubscriptionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CancelSubscription, request);
        }
 
        template<typename CancelSubscriptionRequestT = Model::CancelSubscriptionRequest>
        void CancelSubscriptionAsync(const CancelSubscriptionRequestT& request, const CancelSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CancelSubscription, request, handler, context);
        }
 
        virtual Model::CreateAccountPoolOutcome CreateAccountPool(const Model::CreateAccountPoolRequest& request) const;
 
        template<typename CreateAccountPoolRequestT = Model::CreateAccountPoolRequest>
        Model::CreateAccountPoolOutcomeCallable CreateAccountPoolCallable(const CreateAccountPoolRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateAccountPool, request);
        }
 
        template<typename CreateAccountPoolRequestT = Model::CreateAccountPoolRequest>
        void CreateAccountPoolAsync(const CreateAccountPoolRequestT& request, const CreateAccountPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateAccountPool, request, handler, context);
        }
 
        virtual Model::CreateAssetOutcome CreateAsset(const Model::CreateAssetRequest& request) const;
 
        template<typename CreateAssetRequestT = Model::CreateAssetRequest>
        Model::CreateAssetOutcomeCallable CreateAssetCallable(const CreateAssetRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateAsset, request);
        }
 
        template<typename CreateAssetRequestT = Model::CreateAssetRequest>
        void CreateAssetAsync(const CreateAssetRequestT& request, const CreateAssetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateAsset, request, handler, context);
        }
 
        virtual Model::CreateAssetFilterOutcome CreateAssetFilter(const Model::CreateAssetFilterRequest& request) const;
 
        template<typename CreateAssetFilterRequestT = Model::CreateAssetFilterRequest>
        Model::CreateAssetFilterOutcomeCallable CreateAssetFilterCallable(const CreateAssetFilterRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateAssetFilter, request);
        }
 
        template<typename CreateAssetFilterRequestT = Model::CreateAssetFilterRequest>
        void CreateAssetFilterAsync(const CreateAssetFilterRequestT& request, const CreateAssetFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateAssetFilter, request, handler, context);
        }
 
        virtual Model::CreateAssetRevisionOutcome CreateAssetRevision(const Model::CreateAssetRevisionRequest& request) const;
 
        template<typename CreateAssetRevisionRequestT = Model::CreateAssetRevisionRequest>
        Model::CreateAssetRevisionOutcomeCallable CreateAssetRevisionCallable(const CreateAssetRevisionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateAssetRevision, request);
        }
 
        template<typename CreateAssetRevisionRequestT = Model::CreateAssetRevisionRequest>
        void CreateAssetRevisionAsync(const CreateAssetRevisionRequestT& request, const CreateAssetRevisionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateAssetRevision, request, handler, context);
        }
 
        virtual Model::CreateAssetTypeOutcome CreateAssetType(const Model::CreateAssetTypeRequest& request) const;
 
        template<typename CreateAssetTypeRequestT = Model::CreateAssetTypeRequest>
        Model::CreateAssetTypeOutcomeCallable CreateAssetTypeCallable(const CreateAssetTypeRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateAssetType, request);
        }
 
        template<typename CreateAssetTypeRequestT = Model::CreateAssetTypeRequest>
        void CreateAssetTypeAsync(const CreateAssetTypeRequestT& request, const CreateAssetTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateAssetType, request, handler, context);
        }
 
        virtual Model::CreateConnectionOutcome CreateConnection(const Model::CreateConnectionRequest& request) const;
 
        template<typename CreateConnectionRequestT = Model::CreateConnectionRequest>
        Model::CreateConnectionOutcomeCallable CreateConnectionCallable(const CreateConnectionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateConnection, request);
        }
 
        template<typename CreateConnectionRequestT = Model::CreateConnectionRequest>
        void CreateConnectionAsync(const CreateConnectionRequestT& request, const CreateConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateConnection, request, handler, context);
        }
 
        virtual Model::CreateDataProductOutcome CreateDataProduct(const Model::CreateDataProductRequest& request) const;
 
        template<typename CreateDataProductRequestT = Model::CreateDataProductRequest>
        Model::CreateDataProductOutcomeCallable CreateDataProductCallable(const CreateDataProductRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateDataProduct, request);
        }
 
        template<typename CreateDataProductRequestT = Model::CreateDataProductRequest>
        void CreateDataProductAsync(const CreateDataProductRequestT& request, const CreateDataProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateDataProduct, request, handler, context);
        }
 
        virtual Model::CreateDataProductRevisionOutcome CreateDataProductRevision(const Model::CreateDataProductRevisionRequest& request) const;
 
        template<typename CreateDataProductRevisionRequestT = Model::CreateDataProductRevisionRequest>
        Model::CreateDataProductRevisionOutcomeCallable CreateDataProductRevisionCallable(const CreateDataProductRevisionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateDataProductRevision, request);
        }
 
        template<typename CreateDataProductRevisionRequestT = Model::CreateDataProductRevisionRequest>
        void CreateDataProductRevisionAsync(const CreateDataProductRevisionRequestT& request, const CreateDataProductRevisionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateDataProductRevision, 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(&DataZoneClient::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(&DataZoneClient::CreateDataSource, request, handler, context);
        }
 
        virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const;
 
        template<typename CreateDomainRequestT = Model::CreateDomainRequest>
        Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateDomain, request);
        }
 
        template<typename CreateDomainRequestT = Model::CreateDomainRequest>
        void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateDomain, request, handler, context);
        }
 
        virtual Model::CreateDomainUnitOutcome CreateDomainUnit(const Model::CreateDomainUnitRequest& request) const;
 
        template<typename CreateDomainUnitRequestT = Model::CreateDomainUnitRequest>
        Model::CreateDomainUnitOutcomeCallable CreateDomainUnitCallable(const CreateDomainUnitRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateDomainUnit, request);
        }
 
        template<typename CreateDomainUnitRequestT = Model::CreateDomainUnitRequest>
        void CreateDomainUnitAsync(const CreateDomainUnitRequestT& request, const CreateDomainUnitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateDomainUnit, request, handler, context);
        }
 
        virtual Model::CreateEnvironmentOutcome CreateEnvironment(const Model::CreateEnvironmentRequest& request) const;
 
        template<typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
        Model::CreateEnvironmentOutcomeCallable CreateEnvironmentCallable(const CreateEnvironmentRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateEnvironment, request);
        }
 
        template<typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
        void CreateEnvironmentAsync(const CreateEnvironmentRequestT& request, const CreateEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateEnvironment, request, handler, context);
        }
 
        virtual Model::CreateEnvironmentActionOutcome CreateEnvironmentAction(const Model::CreateEnvironmentActionRequest& request) const;
 
        template<typename CreateEnvironmentActionRequestT = Model::CreateEnvironmentActionRequest>
        Model::CreateEnvironmentActionOutcomeCallable CreateEnvironmentActionCallable(const CreateEnvironmentActionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateEnvironmentAction, request);
        }
 
        template<typename CreateEnvironmentActionRequestT = Model::CreateEnvironmentActionRequest>
        void CreateEnvironmentActionAsync(const CreateEnvironmentActionRequestT& request, const CreateEnvironmentActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateEnvironmentAction, request, handler, context);
        }
 
        virtual Model::CreateEnvironmentProfileOutcome CreateEnvironmentProfile(const Model::CreateEnvironmentProfileRequest& request) const;
 
        template<typename CreateEnvironmentProfileRequestT = Model::CreateEnvironmentProfileRequest>
        Model::CreateEnvironmentProfileOutcomeCallable CreateEnvironmentProfileCallable(const CreateEnvironmentProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateEnvironmentProfile, request);
        }
 
        template<typename CreateEnvironmentProfileRequestT = Model::CreateEnvironmentProfileRequest>
        void CreateEnvironmentProfileAsync(const CreateEnvironmentProfileRequestT& request, const CreateEnvironmentProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateEnvironmentProfile, request, handler, context);
        }
 
        virtual Model::CreateFormTypeOutcome CreateFormType(const Model::CreateFormTypeRequest& request) const;
 
        template<typename CreateFormTypeRequestT = Model::CreateFormTypeRequest>
        Model::CreateFormTypeOutcomeCallable CreateFormTypeCallable(const CreateFormTypeRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateFormType, request);
        }
 
        template<typename CreateFormTypeRequestT = Model::CreateFormTypeRequest>
        void CreateFormTypeAsync(const CreateFormTypeRequestT& request, const CreateFormTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateFormType, request, handler, context);
        }
 
        virtual Model::CreateGlossaryOutcome CreateGlossary(const Model::CreateGlossaryRequest& request) const;
 
        template<typename CreateGlossaryRequestT = Model::CreateGlossaryRequest>
        Model::CreateGlossaryOutcomeCallable CreateGlossaryCallable(const CreateGlossaryRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateGlossary, request);
        }
 
        template<typename CreateGlossaryRequestT = Model::CreateGlossaryRequest>
        void CreateGlossaryAsync(const CreateGlossaryRequestT& request, const CreateGlossaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateGlossary, request, handler, context);
        }
 
        virtual Model::CreateGlossaryTermOutcome CreateGlossaryTerm(const Model::CreateGlossaryTermRequest& request) const;
 
        template<typename CreateGlossaryTermRequestT = Model::CreateGlossaryTermRequest>
        Model::CreateGlossaryTermOutcomeCallable CreateGlossaryTermCallable(const CreateGlossaryTermRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateGlossaryTerm, request);
        }
 
        template<typename CreateGlossaryTermRequestT = Model::CreateGlossaryTermRequest>
        void CreateGlossaryTermAsync(const CreateGlossaryTermRequestT& request, const CreateGlossaryTermResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateGlossaryTerm, request, handler, context);
        }
 
        virtual Model::CreateGroupProfileOutcome CreateGroupProfile(const Model::CreateGroupProfileRequest& request) const;
 
        template<typename CreateGroupProfileRequestT = Model::CreateGroupProfileRequest>
        Model::CreateGroupProfileOutcomeCallable CreateGroupProfileCallable(const CreateGroupProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateGroupProfile, request);
        }
 
        template<typename CreateGroupProfileRequestT = Model::CreateGroupProfileRequest>
        void CreateGroupProfileAsync(const CreateGroupProfileRequestT& request, const CreateGroupProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateGroupProfile, request, handler, context);
        }
 
        virtual Model::CreateListingChangeSetOutcome CreateListingChangeSet(const Model::CreateListingChangeSetRequest& request) const;
 
        template<typename CreateListingChangeSetRequestT = Model::CreateListingChangeSetRequest>
        Model::CreateListingChangeSetOutcomeCallable CreateListingChangeSetCallable(const CreateListingChangeSetRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateListingChangeSet, request);
        }
 
        template<typename CreateListingChangeSetRequestT = Model::CreateListingChangeSetRequest>
        void CreateListingChangeSetAsync(const CreateListingChangeSetRequestT& request, const CreateListingChangeSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateListingChangeSet, request, handler, context);
        }
 
        virtual Model::CreateProjectOutcome CreateProject(const Model::CreateProjectRequest& request) const;
 
        template<typename CreateProjectRequestT = Model::CreateProjectRequest>
        Model::CreateProjectOutcomeCallable CreateProjectCallable(const CreateProjectRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateProject, request);
        }
 
        template<typename CreateProjectRequestT = Model::CreateProjectRequest>
        void CreateProjectAsync(const CreateProjectRequestT& request, const CreateProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateProject, request, handler, context);
        }
 
        virtual Model::CreateProjectMembershipOutcome CreateProjectMembership(const Model::CreateProjectMembershipRequest& request) const;
 
        template<typename CreateProjectMembershipRequestT = Model::CreateProjectMembershipRequest>
        Model::CreateProjectMembershipOutcomeCallable CreateProjectMembershipCallable(const CreateProjectMembershipRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateProjectMembership, request);
        }
 
        template<typename CreateProjectMembershipRequestT = Model::CreateProjectMembershipRequest>
        void CreateProjectMembershipAsync(const CreateProjectMembershipRequestT& request, const CreateProjectMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateProjectMembership, request, handler, context);
        }
 
        virtual Model::CreateProjectProfileOutcome CreateProjectProfile(const Model::CreateProjectProfileRequest& request) const;
 
        template<typename CreateProjectProfileRequestT = Model::CreateProjectProfileRequest>
        Model::CreateProjectProfileOutcomeCallable CreateProjectProfileCallable(const CreateProjectProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateProjectProfile, request);
        }
 
        template<typename CreateProjectProfileRequestT = Model::CreateProjectProfileRequest>
        void CreateProjectProfileAsync(const CreateProjectProfileRequestT& request, const CreateProjectProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateProjectProfile, request, handler, context);
        }
 
        virtual Model::CreateRuleOutcome CreateRule(const Model::CreateRuleRequest& request) const;
 
        template<typename CreateRuleRequestT = Model::CreateRuleRequest>
        Model::CreateRuleOutcomeCallable CreateRuleCallable(const CreateRuleRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateRule, request);
        }
 
        template<typename CreateRuleRequestT = Model::CreateRuleRequest>
        void CreateRuleAsync(const CreateRuleRequestT& request, const CreateRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateRule, request, handler, context);
        }
 
        virtual Model::CreateSubscriptionGrantOutcome CreateSubscriptionGrant(const Model::CreateSubscriptionGrantRequest& request) const;
 
        template<typename CreateSubscriptionGrantRequestT = Model::CreateSubscriptionGrantRequest>
        Model::CreateSubscriptionGrantOutcomeCallable CreateSubscriptionGrantCallable(const CreateSubscriptionGrantRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateSubscriptionGrant, request);
        }
 
        template<typename CreateSubscriptionGrantRequestT = Model::CreateSubscriptionGrantRequest>
        void CreateSubscriptionGrantAsync(const CreateSubscriptionGrantRequestT& request, const CreateSubscriptionGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateSubscriptionGrant, request, handler, context);
        }
 
        virtual Model::CreateSubscriptionRequestOutcome CreateSubscriptionRequest(const Model::CreateSubscriptionRequestRequest& request) const;
 
        template<typename CreateSubscriptionRequestRequestT = Model::CreateSubscriptionRequestRequest>
        Model::CreateSubscriptionRequestOutcomeCallable CreateSubscriptionRequestCallable(const CreateSubscriptionRequestRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateSubscriptionRequest, request);
        }
 
        template<typename CreateSubscriptionRequestRequestT = Model::CreateSubscriptionRequestRequest>
        void CreateSubscriptionRequestAsync(const CreateSubscriptionRequestRequestT& request, const CreateSubscriptionRequestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateSubscriptionRequest, request, handler, context);
        }
 
        virtual Model::CreateSubscriptionTargetOutcome CreateSubscriptionTarget(const Model::CreateSubscriptionTargetRequest& request) const;
 
        template<typename CreateSubscriptionTargetRequestT = Model::CreateSubscriptionTargetRequest>
        Model::CreateSubscriptionTargetOutcomeCallable CreateSubscriptionTargetCallable(const CreateSubscriptionTargetRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateSubscriptionTarget, request);
        }
 
        template<typename CreateSubscriptionTargetRequestT = Model::CreateSubscriptionTargetRequest>
        void CreateSubscriptionTargetAsync(const CreateSubscriptionTargetRequestT& request, const CreateSubscriptionTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateSubscriptionTarget, request, handler, context);
        }
 
        virtual Model::CreateUserProfileOutcome CreateUserProfile(const Model::CreateUserProfileRequest& request) const;
 
        template<typename CreateUserProfileRequestT = Model::CreateUserProfileRequest>
        Model::CreateUserProfileOutcomeCallable CreateUserProfileCallable(const CreateUserProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::CreateUserProfile, request);
        }
 
        template<typename CreateUserProfileRequestT = Model::CreateUserProfileRequest>
        void CreateUserProfileAsync(const CreateUserProfileRequestT& request, const CreateUserProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::CreateUserProfile, request, handler, context);
        }
 
        virtual Model::DeleteAccountPoolOutcome DeleteAccountPool(const Model::DeleteAccountPoolRequest& request) const;
 
        template<typename DeleteAccountPoolRequestT = Model::DeleteAccountPoolRequest>
        Model::DeleteAccountPoolOutcomeCallable DeleteAccountPoolCallable(const DeleteAccountPoolRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteAccountPool, request);
        }
 
        template<typename DeleteAccountPoolRequestT = Model::DeleteAccountPoolRequest>
        void DeleteAccountPoolAsync(const DeleteAccountPoolRequestT& request, const DeleteAccountPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteAccountPool, request, handler, context);
        }
 
        virtual Model::DeleteAssetOutcome DeleteAsset(const Model::DeleteAssetRequest& request) const;
 
        template<typename DeleteAssetRequestT = Model::DeleteAssetRequest>
        Model::DeleteAssetOutcomeCallable DeleteAssetCallable(const DeleteAssetRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteAsset, request);
        }
 
        template<typename DeleteAssetRequestT = Model::DeleteAssetRequest>
        void DeleteAssetAsync(const DeleteAssetRequestT& request, const DeleteAssetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteAsset, request, handler, context);
        }
 
        virtual Model::DeleteAssetFilterOutcome DeleteAssetFilter(const Model::DeleteAssetFilterRequest& request) const;
 
        template<typename DeleteAssetFilterRequestT = Model::DeleteAssetFilterRequest>
        Model::DeleteAssetFilterOutcomeCallable DeleteAssetFilterCallable(const DeleteAssetFilterRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteAssetFilter, request);
        }
 
        template<typename DeleteAssetFilterRequestT = Model::DeleteAssetFilterRequest>
        void DeleteAssetFilterAsync(const DeleteAssetFilterRequestT& request, const DeleteAssetFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteAssetFilter, request, handler, context);
        }
 
        virtual Model::DeleteAssetTypeOutcome DeleteAssetType(const Model::DeleteAssetTypeRequest& request) const;
 
        template<typename DeleteAssetTypeRequestT = Model::DeleteAssetTypeRequest>
        Model::DeleteAssetTypeOutcomeCallable DeleteAssetTypeCallable(const DeleteAssetTypeRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteAssetType, request);
        }
 
        template<typename DeleteAssetTypeRequestT = Model::DeleteAssetTypeRequest>
        void DeleteAssetTypeAsync(const DeleteAssetTypeRequestT& request, const DeleteAssetTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteAssetType, request, handler, context);
        }
 
        virtual Model::DeleteConnectionOutcome DeleteConnection(const Model::DeleteConnectionRequest& request) const;
 
        template<typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
        Model::DeleteConnectionOutcomeCallable DeleteConnectionCallable(const DeleteConnectionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteConnection, request);
        }
 
        template<typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
        void DeleteConnectionAsync(const DeleteConnectionRequestT& request, const DeleteConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteConnection, request, handler, context);
        }
 
        virtual Model::DeleteDataProductOutcome DeleteDataProduct(const Model::DeleteDataProductRequest& request) const;
 
        template<typename DeleteDataProductRequestT = Model::DeleteDataProductRequest>
        Model::DeleteDataProductOutcomeCallable DeleteDataProductCallable(const DeleteDataProductRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteDataProduct, request);
        }
 
        template<typename DeleteDataProductRequestT = Model::DeleteDataProductRequest>
        void DeleteDataProductAsync(const DeleteDataProductRequestT& request, const DeleteDataProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteDataProduct, 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(&DataZoneClient::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(&DataZoneClient::DeleteDataSource, request, handler, context);
        }
 
        virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const;
 
        template<typename DeleteDomainRequestT = Model::DeleteDomainRequest>
        Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteDomain, request);
        }
 
        template<typename DeleteDomainRequestT = Model::DeleteDomainRequest>
        void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteDomain, request, handler, context);
        }
 
        virtual Model::DeleteDomainUnitOutcome DeleteDomainUnit(const Model::DeleteDomainUnitRequest& request) const;
 
        template<typename DeleteDomainUnitRequestT = Model::DeleteDomainUnitRequest>
        Model::DeleteDomainUnitOutcomeCallable DeleteDomainUnitCallable(const DeleteDomainUnitRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteDomainUnit, request);
        }
 
        template<typename DeleteDomainUnitRequestT = Model::DeleteDomainUnitRequest>
        void DeleteDomainUnitAsync(const DeleteDomainUnitRequestT& request, const DeleteDomainUnitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteDomainUnit, request, handler, context);
        }
 
        virtual Model::DeleteEnvironmentOutcome DeleteEnvironment(const Model::DeleteEnvironmentRequest& request) const;
 
        template<typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
        Model::DeleteEnvironmentOutcomeCallable DeleteEnvironmentCallable(const DeleteEnvironmentRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteEnvironment, request);
        }
 
        template<typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
        void DeleteEnvironmentAsync(const DeleteEnvironmentRequestT& request, const DeleteEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteEnvironment, request, handler, context);
        }
 
        virtual Model::DeleteEnvironmentActionOutcome DeleteEnvironmentAction(const Model::DeleteEnvironmentActionRequest& request) const;
 
        template<typename DeleteEnvironmentActionRequestT = Model::DeleteEnvironmentActionRequest>
        Model::DeleteEnvironmentActionOutcomeCallable DeleteEnvironmentActionCallable(const DeleteEnvironmentActionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteEnvironmentAction, request);
        }
 
        template<typename DeleteEnvironmentActionRequestT = Model::DeleteEnvironmentActionRequest>
        void DeleteEnvironmentActionAsync(const DeleteEnvironmentActionRequestT& request, const DeleteEnvironmentActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteEnvironmentAction, request, handler, context);
        }
 
        virtual Model::DeleteEnvironmentBlueprintConfigurationOutcome DeleteEnvironmentBlueprintConfiguration(const Model::DeleteEnvironmentBlueprintConfigurationRequest& request) const;
 
        template<typename DeleteEnvironmentBlueprintConfigurationRequestT = Model::DeleteEnvironmentBlueprintConfigurationRequest>
        Model::DeleteEnvironmentBlueprintConfigurationOutcomeCallable DeleteEnvironmentBlueprintConfigurationCallable(const DeleteEnvironmentBlueprintConfigurationRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteEnvironmentBlueprintConfiguration, request);
        }
 
        template<typename DeleteEnvironmentBlueprintConfigurationRequestT = Model::DeleteEnvironmentBlueprintConfigurationRequest>
        void DeleteEnvironmentBlueprintConfigurationAsync(const DeleteEnvironmentBlueprintConfigurationRequestT& request, const DeleteEnvironmentBlueprintConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteEnvironmentBlueprintConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteEnvironmentProfileOutcome DeleteEnvironmentProfile(const Model::DeleteEnvironmentProfileRequest& request) const;
 
        template<typename DeleteEnvironmentProfileRequestT = Model::DeleteEnvironmentProfileRequest>
        Model::DeleteEnvironmentProfileOutcomeCallable DeleteEnvironmentProfileCallable(const DeleteEnvironmentProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteEnvironmentProfile, request);
        }
 
        template<typename DeleteEnvironmentProfileRequestT = Model::DeleteEnvironmentProfileRequest>
        void DeleteEnvironmentProfileAsync(const DeleteEnvironmentProfileRequestT& request, const DeleteEnvironmentProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteEnvironmentProfile, request, handler, context);
        }
 
        virtual Model::DeleteFormTypeOutcome DeleteFormType(const Model::DeleteFormTypeRequest& request) const;
 
        template<typename DeleteFormTypeRequestT = Model::DeleteFormTypeRequest>
        Model::DeleteFormTypeOutcomeCallable DeleteFormTypeCallable(const DeleteFormTypeRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteFormType, request);
        }
 
        template<typename DeleteFormTypeRequestT = Model::DeleteFormTypeRequest>
        void DeleteFormTypeAsync(const DeleteFormTypeRequestT& request, const DeleteFormTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteFormType, request, handler, context);
        }
 
        virtual Model::DeleteGlossaryOutcome DeleteGlossary(const Model::DeleteGlossaryRequest& request) const;
 
        template<typename DeleteGlossaryRequestT = Model::DeleteGlossaryRequest>
        Model::DeleteGlossaryOutcomeCallable DeleteGlossaryCallable(const DeleteGlossaryRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteGlossary, request);
        }
 
        template<typename DeleteGlossaryRequestT = Model::DeleteGlossaryRequest>
        void DeleteGlossaryAsync(const DeleteGlossaryRequestT& request, const DeleteGlossaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteGlossary, request, handler, context);
        }
 
        virtual Model::DeleteGlossaryTermOutcome DeleteGlossaryTerm(const Model::DeleteGlossaryTermRequest& request) const;
 
        template<typename DeleteGlossaryTermRequestT = Model::DeleteGlossaryTermRequest>
        Model::DeleteGlossaryTermOutcomeCallable DeleteGlossaryTermCallable(const DeleteGlossaryTermRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteGlossaryTerm, request);
        }
 
        template<typename DeleteGlossaryTermRequestT = Model::DeleteGlossaryTermRequest>
        void DeleteGlossaryTermAsync(const DeleteGlossaryTermRequestT& request, const DeleteGlossaryTermResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteGlossaryTerm, request, handler, context);
        }
 
        virtual Model::DeleteListingOutcome DeleteListing(const Model::DeleteListingRequest& request) const;
 
        template<typename DeleteListingRequestT = Model::DeleteListingRequest>
        Model::DeleteListingOutcomeCallable DeleteListingCallable(const DeleteListingRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteListing, request);
        }
 
        template<typename DeleteListingRequestT = Model::DeleteListingRequest>
        void DeleteListingAsync(const DeleteListingRequestT& request, const DeleteListingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteListing, request, handler, context);
        }
 
        virtual Model::DeleteProjectOutcome DeleteProject(const Model::DeleteProjectRequest& request) const;
 
        template<typename DeleteProjectRequestT = Model::DeleteProjectRequest>
        Model::DeleteProjectOutcomeCallable DeleteProjectCallable(const DeleteProjectRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteProject, request);
        }
 
        template<typename DeleteProjectRequestT = Model::DeleteProjectRequest>
        void DeleteProjectAsync(const DeleteProjectRequestT& request, const DeleteProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteProject, request, handler, context);
        }
 
        virtual Model::DeleteProjectMembershipOutcome DeleteProjectMembership(const Model::DeleteProjectMembershipRequest& request) const;
 
        template<typename DeleteProjectMembershipRequestT = Model::DeleteProjectMembershipRequest>
        Model::DeleteProjectMembershipOutcomeCallable DeleteProjectMembershipCallable(const DeleteProjectMembershipRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteProjectMembership, request);
        }
 
        template<typename DeleteProjectMembershipRequestT = Model::DeleteProjectMembershipRequest>
        void DeleteProjectMembershipAsync(const DeleteProjectMembershipRequestT& request, const DeleteProjectMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteProjectMembership, request, handler, context);
        }
 
        virtual Model::DeleteProjectProfileOutcome DeleteProjectProfile(const Model::DeleteProjectProfileRequest& request) const;
 
        template<typename DeleteProjectProfileRequestT = Model::DeleteProjectProfileRequest>
        Model::DeleteProjectProfileOutcomeCallable DeleteProjectProfileCallable(const DeleteProjectProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteProjectProfile, request);
        }
 
        template<typename DeleteProjectProfileRequestT = Model::DeleteProjectProfileRequest>
        void DeleteProjectProfileAsync(const DeleteProjectProfileRequestT& request, const DeleteProjectProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteProjectProfile, request, handler, context);
        }
 
        virtual Model::DeleteRuleOutcome DeleteRule(const Model::DeleteRuleRequest& request) const;
 
        template<typename DeleteRuleRequestT = Model::DeleteRuleRequest>
        Model::DeleteRuleOutcomeCallable DeleteRuleCallable(const DeleteRuleRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteRule, request);
        }
 
        template<typename DeleteRuleRequestT = Model::DeleteRuleRequest>
        void DeleteRuleAsync(const DeleteRuleRequestT& request, const DeleteRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteRule, request, handler, context);
        }
 
        virtual Model::DeleteSubscriptionGrantOutcome DeleteSubscriptionGrant(const Model::DeleteSubscriptionGrantRequest& request) const;
 
        template<typename DeleteSubscriptionGrantRequestT = Model::DeleteSubscriptionGrantRequest>
        Model::DeleteSubscriptionGrantOutcomeCallable DeleteSubscriptionGrantCallable(const DeleteSubscriptionGrantRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteSubscriptionGrant, request);
        }
 
        template<typename DeleteSubscriptionGrantRequestT = Model::DeleteSubscriptionGrantRequest>
        void DeleteSubscriptionGrantAsync(const DeleteSubscriptionGrantRequestT& request, const DeleteSubscriptionGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteSubscriptionGrant, request, handler, context);
        }
 
        virtual Model::DeleteSubscriptionRequestOutcome DeleteSubscriptionRequest(const Model::DeleteSubscriptionRequestRequest& request) const;
 
        template<typename DeleteSubscriptionRequestRequestT = Model::DeleteSubscriptionRequestRequest>
        Model::DeleteSubscriptionRequestOutcomeCallable DeleteSubscriptionRequestCallable(const DeleteSubscriptionRequestRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteSubscriptionRequest, request);
        }
 
        template<typename DeleteSubscriptionRequestRequestT = Model::DeleteSubscriptionRequestRequest>
        void DeleteSubscriptionRequestAsync(const DeleteSubscriptionRequestRequestT& request, const DeleteSubscriptionRequestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteSubscriptionRequest, request, handler, context);
        }
 
        virtual Model::DeleteSubscriptionTargetOutcome DeleteSubscriptionTarget(const Model::DeleteSubscriptionTargetRequest& request) const;
 
        template<typename DeleteSubscriptionTargetRequestT = Model::DeleteSubscriptionTargetRequest>
        Model::DeleteSubscriptionTargetOutcomeCallable DeleteSubscriptionTargetCallable(const DeleteSubscriptionTargetRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteSubscriptionTarget, request);
        }
 
        template<typename DeleteSubscriptionTargetRequestT = Model::DeleteSubscriptionTargetRequest>
        void DeleteSubscriptionTargetAsync(const DeleteSubscriptionTargetRequestT& request, const DeleteSubscriptionTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteSubscriptionTarget, request, handler, context);
        }
 
        virtual Model::DeleteTimeSeriesDataPointsOutcome DeleteTimeSeriesDataPoints(const Model::DeleteTimeSeriesDataPointsRequest& request) const;
 
        template<typename DeleteTimeSeriesDataPointsRequestT = Model::DeleteTimeSeriesDataPointsRequest>
        Model::DeleteTimeSeriesDataPointsOutcomeCallable DeleteTimeSeriesDataPointsCallable(const DeleteTimeSeriesDataPointsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DeleteTimeSeriesDataPoints, request);
        }
 
        template<typename DeleteTimeSeriesDataPointsRequestT = Model::DeleteTimeSeriesDataPointsRequest>
        void DeleteTimeSeriesDataPointsAsync(const DeleteTimeSeriesDataPointsRequestT& request, const DeleteTimeSeriesDataPointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DeleteTimeSeriesDataPoints, request, handler, context);
        }
 
        virtual Model::DisassociateEnvironmentRoleOutcome DisassociateEnvironmentRole(const Model::DisassociateEnvironmentRoleRequest& request) const;
 
        template<typename DisassociateEnvironmentRoleRequestT = Model::DisassociateEnvironmentRoleRequest>
        Model::DisassociateEnvironmentRoleOutcomeCallable DisassociateEnvironmentRoleCallable(const DisassociateEnvironmentRoleRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DisassociateEnvironmentRole, request);
        }
 
        template<typename DisassociateEnvironmentRoleRequestT = Model::DisassociateEnvironmentRoleRequest>
        void DisassociateEnvironmentRoleAsync(const DisassociateEnvironmentRoleRequestT& request, const DisassociateEnvironmentRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DisassociateEnvironmentRole, request, handler, context);
        }
 
        virtual Model::DisassociateGovernedTermsOutcome DisassociateGovernedTerms(const Model::DisassociateGovernedTermsRequest& request) const;
 
        template<typename DisassociateGovernedTermsRequestT = Model::DisassociateGovernedTermsRequest>
        Model::DisassociateGovernedTermsOutcomeCallable DisassociateGovernedTermsCallable(const DisassociateGovernedTermsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::DisassociateGovernedTerms, request);
        }
 
        template<typename DisassociateGovernedTermsRequestT = Model::DisassociateGovernedTermsRequest>
        void DisassociateGovernedTermsAsync(const DisassociateGovernedTermsRequestT& request, const DisassociateGovernedTermsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::DisassociateGovernedTerms, request, handler, context);
        }
 
        virtual Model::GetAccountPoolOutcome GetAccountPool(const Model::GetAccountPoolRequest& request) const;
 
        template<typename GetAccountPoolRequestT = Model::GetAccountPoolRequest>
        Model::GetAccountPoolOutcomeCallable GetAccountPoolCallable(const GetAccountPoolRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetAccountPool, request);
        }
 
        template<typename GetAccountPoolRequestT = Model::GetAccountPoolRequest>
        void GetAccountPoolAsync(const GetAccountPoolRequestT& request, const GetAccountPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetAccountPool, request, handler, context);
        }
 
        virtual Model::GetAssetOutcome GetAsset(const Model::GetAssetRequest& request) const;
 
        template<typename GetAssetRequestT = Model::GetAssetRequest>
        Model::GetAssetOutcomeCallable GetAssetCallable(const GetAssetRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetAsset, request);
        }
 
        template<typename GetAssetRequestT = Model::GetAssetRequest>
        void GetAssetAsync(const GetAssetRequestT& request, const GetAssetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetAsset, request, handler, context);
        }
 
        virtual Model::GetAssetFilterOutcome GetAssetFilter(const Model::GetAssetFilterRequest& request) const;
 
        template<typename GetAssetFilterRequestT = Model::GetAssetFilterRequest>
        Model::GetAssetFilterOutcomeCallable GetAssetFilterCallable(const GetAssetFilterRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetAssetFilter, request);
        }
 
        template<typename GetAssetFilterRequestT = Model::GetAssetFilterRequest>
        void GetAssetFilterAsync(const GetAssetFilterRequestT& request, const GetAssetFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetAssetFilter, request, handler, context);
        }
 
        virtual Model::GetAssetTypeOutcome GetAssetType(const Model::GetAssetTypeRequest& request) const;
 
        template<typename GetAssetTypeRequestT = Model::GetAssetTypeRequest>
        Model::GetAssetTypeOutcomeCallable GetAssetTypeCallable(const GetAssetTypeRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetAssetType, request);
        }
 
        template<typename GetAssetTypeRequestT = Model::GetAssetTypeRequest>
        void GetAssetTypeAsync(const GetAssetTypeRequestT& request, const GetAssetTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetAssetType, request, handler, context);
        }
 
        virtual Model::GetConnectionOutcome GetConnection(const Model::GetConnectionRequest& request) const;
 
        template<typename GetConnectionRequestT = Model::GetConnectionRequest>
        Model::GetConnectionOutcomeCallable GetConnectionCallable(const GetConnectionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetConnection, request);
        }
 
        template<typename GetConnectionRequestT = Model::GetConnectionRequest>
        void GetConnectionAsync(const GetConnectionRequestT& request, const GetConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetConnection, request, handler, context);
        }
 
        virtual Model::GetDataProductOutcome GetDataProduct(const Model::GetDataProductRequest& request) const;
 
        template<typename GetDataProductRequestT = Model::GetDataProductRequest>
        Model::GetDataProductOutcomeCallable GetDataProductCallable(const GetDataProductRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetDataProduct, request);
        }
 
        template<typename GetDataProductRequestT = Model::GetDataProductRequest>
        void GetDataProductAsync(const GetDataProductRequestT& request, const GetDataProductResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetDataProduct, 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(&DataZoneClient::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(&DataZoneClient::GetDataSource, request, handler, context);
        }
 
        virtual Model::GetDataSourceRunOutcome GetDataSourceRun(const Model::GetDataSourceRunRequest& request) const;
 
        template<typename GetDataSourceRunRequestT = Model::GetDataSourceRunRequest>
        Model::GetDataSourceRunOutcomeCallable GetDataSourceRunCallable(const GetDataSourceRunRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetDataSourceRun, request);
        }
 
        template<typename GetDataSourceRunRequestT = Model::GetDataSourceRunRequest>
        void GetDataSourceRunAsync(const GetDataSourceRunRequestT& request, const GetDataSourceRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetDataSourceRun, request, handler, context);
        }
 
        virtual Model::GetDomainOutcome GetDomain(const Model::GetDomainRequest& request) const;
 
        template<typename GetDomainRequestT = Model::GetDomainRequest>
        Model::GetDomainOutcomeCallable GetDomainCallable(const GetDomainRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetDomain, request);
        }
 
        template<typename GetDomainRequestT = Model::GetDomainRequest>
        void GetDomainAsync(const GetDomainRequestT& request, const GetDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetDomain, request, handler, context);
        }
 
        virtual Model::GetDomainUnitOutcome GetDomainUnit(const Model::GetDomainUnitRequest& request) const;
 
        template<typename GetDomainUnitRequestT = Model::GetDomainUnitRequest>
        Model::GetDomainUnitOutcomeCallable GetDomainUnitCallable(const GetDomainUnitRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetDomainUnit, request);
        }
 
        template<typename GetDomainUnitRequestT = Model::GetDomainUnitRequest>
        void GetDomainUnitAsync(const GetDomainUnitRequestT& request, const GetDomainUnitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetDomainUnit, request, handler, context);
        }
 
        virtual Model::GetEnvironmentOutcome GetEnvironment(const Model::GetEnvironmentRequest& request) const;
 
        template<typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
        Model::GetEnvironmentOutcomeCallable GetEnvironmentCallable(const GetEnvironmentRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetEnvironment, request);
        }
 
        template<typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
        void GetEnvironmentAsync(const GetEnvironmentRequestT& request, const GetEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetEnvironment, request, handler, context);
        }
 
        virtual Model::GetEnvironmentActionOutcome GetEnvironmentAction(const Model::GetEnvironmentActionRequest& request) const;
 
        template<typename GetEnvironmentActionRequestT = Model::GetEnvironmentActionRequest>
        Model::GetEnvironmentActionOutcomeCallable GetEnvironmentActionCallable(const GetEnvironmentActionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetEnvironmentAction, request);
        }
 
        template<typename GetEnvironmentActionRequestT = Model::GetEnvironmentActionRequest>
        void GetEnvironmentActionAsync(const GetEnvironmentActionRequestT& request, const GetEnvironmentActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetEnvironmentAction, request, handler, context);
        }
 
        virtual Model::GetEnvironmentBlueprintOutcome GetEnvironmentBlueprint(const Model::GetEnvironmentBlueprintRequest& request) const;
 
        template<typename GetEnvironmentBlueprintRequestT = Model::GetEnvironmentBlueprintRequest>
        Model::GetEnvironmentBlueprintOutcomeCallable GetEnvironmentBlueprintCallable(const GetEnvironmentBlueprintRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetEnvironmentBlueprint, request);
        }
 
        template<typename GetEnvironmentBlueprintRequestT = Model::GetEnvironmentBlueprintRequest>
        void GetEnvironmentBlueprintAsync(const GetEnvironmentBlueprintRequestT& request, const GetEnvironmentBlueprintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetEnvironmentBlueprint, request, handler, context);
        }
 
        virtual Model::GetEnvironmentBlueprintConfigurationOutcome GetEnvironmentBlueprintConfiguration(const Model::GetEnvironmentBlueprintConfigurationRequest& request) const;
 
        template<typename GetEnvironmentBlueprintConfigurationRequestT = Model::GetEnvironmentBlueprintConfigurationRequest>
        Model::GetEnvironmentBlueprintConfigurationOutcomeCallable GetEnvironmentBlueprintConfigurationCallable(const GetEnvironmentBlueprintConfigurationRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetEnvironmentBlueprintConfiguration, request);
        }
 
        template<typename GetEnvironmentBlueprintConfigurationRequestT = Model::GetEnvironmentBlueprintConfigurationRequest>
        void GetEnvironmentBlueprintConfigurationAsync(const GetEnvironmentBlueprintConfigurationRequestT& request, const GetEnvironmentBlueprintConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetEnvironmentBlueprintConfiguration, request, handler, context);
        }
 
        virtual Model::GetEnvironmentCredentialsOutcome GetEnvironmentCredentials(const Model::GetEnvironmentCredentialsRequest& request) const;
 
        template<typename GetEnvironmentCredentialsRequestT = Model::GetEnvironmentCredentialsRequest>
        Model::GetEnvironmentCredentialsOutcomeCallable GetEnvironmentCredentialsCallable(const GetEnvironmentCredentialsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetEnvironmentCredentials, request);
        }
 
        template<typename GetEnvironmentCredentialsRequestT = Model::GetEnvironmentCredentialsRequest>
        void GetEnvironmentCredentialsAsync(const GetEnvironmentCredentialsRequestT& request, const GetEnvironmentCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetEnvironmentCredentials, request, handler, context);
        }
 
        virtual Model::GetEnvironmentProfileOutcome GetEnvironmentProfile(const Model::GetEnvironmentProfileRequest& request) const;
 
        template<typename GetEnvironmentProfileRequestT = Model::GetEnvironmentProfileRequest>
        Model::GetEnvironmentProfileOutcomeCallable GetEnvironmentProfileCallable(const GetEnvironmentProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetEnvironmentProfile, request);
        }
 
        template<typename GetEnvironmentProfileRequestT = Model::GetEnvironmentProfileRequest>
        void GetEnvironmentProfileAsync(const GetEnvironmentProfileRequestT& request, const GetEnvironmentProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetEnvironmentProfile, request, handler, context);
        }
 
        virtual Model::GetFormTypeOutcome GetFormType(const Model::GetFormTypeRequest& request) const;
 
        template<typename GetFormTypeRequestT = Model::GetFormTypeRequest>
        Model::GetFormTypeOutcomeCallable GetFormTypeCallable(const GetFormTypeRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetFormType, request);
        }
 
        template<typename GetFormTypeRequestT = Model::GetFormTypeRequest>
        void GetFormTypeAsync(const GetFormTypeRequestT& request, const GetFormTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetFormType, request, handler, context);
        }
 
        virtual Model::GetGlossaryOutcome GetGlossary(const Model::GetGlossaryRequest& request) const;
 
        template<typename GetGlossaryRequestT = Model::GetGlossaryRequest>
        Model::GetGlossaryOutcomeCallable GetGlossaryCallable(const GetGlossaryRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetGlossary, request);
        }
 
        template<typename GetGlossaryRequestT = Model::GetGlossaryRequest>
        void GetGlossaryAsync(const GetGlossaryRequestT& request, const GetGlossaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetGlossary, request, handler, context);
        }
 
        virtual Model::GetGlossaryTermOutcome GetGlossaryTerm(const Model::GetGlossaryTermRequest& request) const;
 
        template<typename GetGlossaryTermRequestT = Model::GetGlossaryTermRequest>
        Model::GetGlossaryTermOutcomeCallable GetGlossaryTermCallable(const GetGlossaryTermRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetGlossaryTerm, request);
        }
 
        template<typename GetGlossaryTermRequestT = Model::GetGlossaryTermRequest>
        void GetGlossaryTermAsync(const GetGlossaryTermRequestT& request, const GetGlossaryTermResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetGlossaryTerm, request, handler, context);
        }
 
        virtual Model::GetGroupProfileOutcome GetGroupProfile(const Model::GetGroupProfileRequest& request) const;
 
        template<typename GetGroupProfileRequestT = Model::GetGroupProfileRequest>
        Model::GetGroupProfileOutcomeCallable GetGroupProfileCallable(const GetGroupProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetGroupProfile, request);
        }
 
        template<typename GetGroupProfileRequestT = Model::GetGroupProfileRequest>
        void GetGroupProfileAsync(const GetGroupProfileRequestT& request, const GetGroupProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetGroupProfile, request, handler, context);
        }
 
        virtual Model::GetIamPortalLoginUrlOutcome GetIamPortalLoginUrl(const Model::GetIamPortalLoginUrlRequest& request) const;
 
        template<typename GetIamPortalLoginUrlRequestT = Model::GetIamPortalLoginUrlRequest>
        Model::GetIamPortalLoginUrlOutcomeCallable GetIamPortalLoginUrlCallable(const GetIamPortalLoginUrlRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetIamPortalLoginUrl, request);
        }
 
        template<typename GetIamPortalLoginUrlRequestT = Model::GetIamPortalLoginUrlRequest>
        void GetIamPortalLoginUrlAsync(const GetIamPortalLoginUrlRequestT& request, const GetIamPortalLoginUrlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetIamPortalLoginUrl, request, handler, context);
        }
 
        virtual Model::GetJobRunOutcome GetJobRun(const Model::GetJobRunRequest& request) const;
 
        template<typename GetJobRunRequestT = Model::GetJobRunRequest>
        Model::GetJobRunOutcomeCallable GetJobRunCallable(const GetJobRunRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetJobRun, request);
        }
 
        template<typename GetJobRunRequestT = Model::GetJobRunRequest>
        void GetJobRunAsync(const GetJobRunRequestT& request, const GetJobRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetJobRun, request, handler, context);
        }
 
        virtual Model::GetLineageEventOutcome GetLineageEvent(const Model::GetLineageEventRequest& request) const;
 
        template<typename GetLineageEventRequestT = Model::GetLineageEventRequest>
        Model::GetLineageEventOutcomeCallable GetLineageEventCallable(const GetLineageEventRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetLineageEvent, request);
        }
 
        template<typename GetLineageEventRequestT = Model::GetLineageEventRequest>
        void GetLineageEventAsync(const GetLineageEventRequestT& request, const GetLineageEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetLineageEvent, request, handler, context);
        }
 
        virtual Model::GetLineageNodeOutcome GetLineageNode(const Model::GetLineageNodeRequest& request) const;
 
        template<typename GetLineageNodeRequestT = Model::GetLineageNodeRequest>
        Model::GetLineageNodeOutcomeCallable GetLineageNodeCallable(const GetLineageNodeRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetLineageNode, request);
        }
 
        template<typename GetLineageNodeRequestT = Model::GetLineageNodeRequest>
        void GetLineageNodeAsync(const GetLineageNodeRequestT& request, const GetLineageNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetLineageNode, request, handler, context);
        }
 
        virtual Model::GetListingOutcome GetListing(const Model::GetListingRequest& request) const;
 
        template<typename GetListingRequestT = Model::GetListingRequest>
        Model::GetListingOutcomeCallable GetListingCallable(const GetListingRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetListing, request);
        }
 
        template<typename GetListingRequestT = Model::GetListingRequest>
        void GetListingAsync(const GetListingRequestT& request, const GetListingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetListing, request, handler, context);
        }
 
        virtual Model::GetMetadataGenerationRunOutcome GetMetadataGenerationRun(const Model::GetMetadataGenerationRunRequest& request) const;
 
        template<typename GetMetadataGenerationRunRequestT = Model::GetMetadataGenerationRunRequest>
        Model::GetMetadataGenerationRunOutcomeCallable GetMetadataGenerationRunCallable(const GetMetadataGenerationRunRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetMetadataGenerationRun, request);
        }
 
        template<typename GetMetadataGenerationRunRequestT = Model::GetMetadataGenerationRunRequest>
        void GetMetadataGenerationRunAsync(const GetMetadataGenerationRunRequestT& request, const GetMetadataGenerationRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetMetadataGenerationRun, request, handler, context);
        }
 
        virtual Model::GetProjectOutcome GetProject(const Model::GetProjectRequest& request) const;
 
        template<typename GetProjectRequestT = Model::GetProjectRequest>
        Model::GetProjectOutcomeCallable GetProjectCallable(const GetProjectRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetProject, request);
        }
 
        template<typename GetProjectRequestT = Model::GetProjectRequest>
        void GetProjectAsync(const GetProjectRequestT& request, const GetProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetProject, request, handler, context);
        }
 
        virtual Model::GetProjectProfileOutcome GetProjectProfile(const Model::GetProjectProfileRequest& request) const;
 
        template<typename GetProjectProfileRequestT = Model::GetProjectProfileRequest>
        Model::GetProjectProfileOutcomeCallable GetProjectProfileCallable(const GetProjectProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetProjectProfile, request);
        }
 
        template<typename GetProjectProfileRequestT = Model::GetProjectProfileRequest>
        void GetProjectProfileAsync(const GetProjectProfileRequestT& request, const GetProjectProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetProjectProfile, request, handler, context);
        }
 
        virtual Model::GetRuleOutcome GetRule(const Model::GetRuleRequest& request) const;
 
        template<typename GetRuleRequestT = Model::GetRuleRequest>
        Model::GetRuleOutcomeCallable GetRuleCallable(const GetRuleRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetRule, request);
        }
 
        template<typename GetRuleRequestT = Model::GetRuleRequest>
        void GetRuleAsync(const GetRuleRequestT& request, const GetRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetRule, request, handler, context);
        }
 
        virtual Model::GetSubscriptionOutcome GetSubscription(const Model::GetSubscriptionRequest& request) const;
 
        template<typename GetSubscriptionRequestT = Model::GetSubscriptionRequest>
        Model::GetSubscriptionOutcomeCallable GetSubscriptionCallable(const GetSubscriptionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetSubscription, request);
        }
 
        template<typename GetSubscriptionRequestT = Model::GetSubscriptionRequest>
        void GetSubscriptionAsync(const GetSubscriptionRequestT& request, const GetSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetSubscription, request, handler, context);
        }
 
        virtual Model::GetSubscriptionGrantOutcome GetSubscriptionGrant(const Model::GetSubscriptionGrantRequest& request) const;
 
        template<typename GetSubscriptionGrantRequestT = Model::GetSubscriptionGrantRequest>
        Model::GetSubscriptionGrantOutcomeCallable GetSubscriptionGrantCallable(const GetSubscriptionGrantRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetSubscriptionGrant, request);
        }
 
        template<typename GetSubscriptionGrantRequestT = Model::GetSubscriptionGrantRequest>
        void GetSubscriptionGrantAsync(const GetSubscriptionGrantRequestT& request, const GetSubscriptionGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetSubscriptionGrant, request, handler, context);
        }
 
        virtual Model::GetSubscriptionRequestDetailsOutcome GetSubscriptionRequestDetails(const Model::GetSubscriptionRequestDetailsRequest& request) const;
 
        template<typename GetSubscriptionRequestDetailsRequestT = Model::GetSubscriptionRequestDetailsRequest>
        Model::GetSubscriptionRequestDetailsOutcomeCallable GetSubscriptionRequestDetailsCallable(const GetSubscriptionRequestDetailsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetSubscriptionRequestDetails, request);
        }
 
        template<typename GetSubscriptionRequestDetailsRequestT = Model::GetSubscriptionRequestDetailsRequest>
        void GetSubscriptionRequestDetailsAsync(const GetSubscriptionRequestDetailsRequestT& request, const GetSubscriptionRequestDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetSubscriptionRequestDetails, request, handler, context);
        }
 
        virtual Model::GetSubscriptionTargetOutcome GetSubscriptionTarget(const Model::GetSubscriptionTargetRequest& request) const;
 
        template<typename GetSubscriptionTargetRequestT = Model::GetSubscriptionTargetRequest>
        Model::GetSubscriptionTargetOutcomeCallable GetSubscriptionTargetCallable(const GetSubscriptionTargetRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetSubscriptionTarget, request);
        }
 
        template<typename GetSubscriptionTargetRequestT = Model::GetSubscriptionTargetRequest>
        void GetSubscriptionTargetAsync(const GetSubscriptionTargetRequestT& request, const GetSubscriptionTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetSubscriptionTarget, request, handler, context);
        }
 
        virtual Model::GetTimeSeriesDataPointOutcome GetTimeSeriesDataPoint(const Model::GetTimeSeriesDataPointRequest& request) const;
 
        template<typename GetTimeSeriesDataPointRequestT = Model::GetTimeSeriesDataPointRequest>
        Model::GetTimeSeriesDataPointOutcomeCallable GetTimeSeriesDataPointCallable(const GetTimeSeriesDataPointRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetTimeSeriesDataPoint, request);
        }
 
        template<typename GetTimeSeriesDataPointRequestT = Model::GetTimeSeriesDataPointRequest>
        void GetTimeSeriesDataPointAsync(const GetTimeSeriesDataPointRequestT& request, const GetTimeSeriesDataPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetTimeSeriesDataPoint, request, handler, context);
        }
 
        virtual Model::GetUserProfileOutcome GetUserProfile(const Model::GetUserProfileRequest& request) const;
 
        template<typename GetUserProfileRequestT = Model::GetUserProfileRequest>
        Model::GetUserProfileOutcomeCallable GetUserProfileCallable(const GetUserProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::GetUserProfile, request);
        }
 
        template<typename GetUserProfileRequestT = Model::GetUserProfileRequest>
        void GetUserProfileAsync(const GetUserProfileRequestT& request, const GetUserProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::GetUserProfile, request, handler, context);
        }
 
        virtual Model::ListAccountPoolsOutcome ListAccountPools(const Model::ListAccountPoolsRequest& request) const;
 
        template<typename ListAccountPoolsRequestT = Model::ListAccountPoolsRequest>
        Model::ListAccountPoolsOutcomeCallable ListAccountPoolsCallable(const ListAccountPoolsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListAccountPools, request);
        }
 
        template<typename ListAccountPoolsRequestT = Model::ListAccountPoolsRequest>
        void ListAccountPoolsAsync(const ListAccountPoolsRequestT& request, const ListAccountPoolsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListAccountPools, request, handler, context);
        }
 
        virtual Model::ListAccountsInAccountPoolOutcome ListAccountsInAccountPool(const Model::ListAccountsInAccountPoolRequest& request) const;
 
        template<typename ListAccountsInAccountPoolRequestT = Model::ListAccountsInAccountPoolRequest>
        Model::ListAccountsInAccountPoolOutcomeCallable ListAccountsInAccountPoolCallable(const ListAccountsInAccountPoolRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListAccountsInAccountPool, request);
        }
 
        template<typename ListAccountsInAccountPoolRequestT = Model::ListAccountsInAccountPoolRequest>
        void ListAccountsInAccountPoolAsync(const ListAccountsInAccountPoolRequestT& request, const ListAccountsInAccountPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListAccountsInAccountPool, request, handler, context);
        }
 
        virtual Model::ListAssetFiltersOutcome ListAssetFilters(const Model::ListAssetFiltersRequest& request) const;
 
        template<typename ListAssetFiltersRequestT = Model::ListAssetFiltersRequest>
        Model::ListAssetFiltersOutcomeCallable ListAssetFiltersCallable(const ListAssetFiltersRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListAssetFilters, request);
        }
 
        template<typename ListAssetFiltersRequestT = Model::ListAssetFiltersRequest>
        void ListAssetFiltersAsync(const ListAssetFiltersRequestT& request, const ListAssetFiltersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListAssetFilters, request, handler, context);
        }
 
        virtual Model::ListAssetRevisionsOutcome ListAssetRevisions(const Model::ListAssetRevisionsRequest& request) const;
 
        template<typename ListAssetRevisionsRequestT = Model::ListAssetRevisionsRequest>
        Model::ListAssetRevisionsOutcomeCallable ListAssetRevisionsCallable(const ListAssetRevisionsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListAssetRevisions, request);
        }
 
        template<typename ListAssetRevisionsRequestT = Model::ListAssetRevisionsRequest>
        void ListAssetRevisionsAsync(const ListAssetRevisionsRequestT& request, const ListAssetRevisionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListAssetRevisions, request, handler, context);
        }
 
        virtual Model::ListConnectionsOutcome ListConnections(const Model::ListConnectionsRequest& request) const;
 
        template<typename ListConnectionsRequestT = Model::ListConnectionsRequest>
        Model::ListConnectionsOutcomeCallable ListConnectionsCallable(const ListConnectionsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListConnections, request);
        }
 
        template<typename ListConnectionsRequestT = Model::ListConnectionsRequest>
        void ListConnectionsAsync(const ListConnectionsRequestT& request, const ListConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListConnections, request, handler, context);
        }
 
        virtual Model::ListDataProductRevisionsOutcome ListDataProductRevisions(const Model::ListDataProductRevisionsRequest& request) const;
 
        template<typename ListDataProductRevisionsRequestT = Model::ListDataProductRevisionsRequest>
        Model::ListDataProductRevisionsOutcomeCallable ListDataProductRevisionsCallable(const ListDataProductRevisionsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListDataProductRevisions, request);
        }
 
        template<typename ListDataProductRevisionsRequestT = Model::ListDataProductRevisionsRequest>
        void ListDataProductRevisionsAsync(const ListDataProductRevisionsRequestT& request, const ListDataProductRevisionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListDataProductRevisions, request, handler, context);
        }
 
        virtual Model::ListDataSourceRunActivitiesOutcome ListDataSourceRunActivities(const Model::ListDataSourceRunActivitiesRequest& request) const;
 
        template<typename ListDataSourceRunActivitiesRequestT = Model::ListDataSourceRunActivitiesRequest>
        Model::ListDataSourceRunActivitiesOutcomeCallable ListDataSourceRunActivitiesCallable(const ListDataSourceRunActivitiesRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListDataSourceRunActivities, request);
        }
 
        template<typename ListDataSourceRunActivitiesRequestT = Model::ListDataSourceRunActivitiesRequest>
        void ListDataSourceRunActivitiesAsync(const ListDataSourceRunActivitiesRequestT& request, const ListDataSourceRunActivitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListDataSourceRunActivities, request, handler, context);
        }
 
        virtual Model::ListDataSourceRunsOutcome ListDataSourceRuns(const Model::ListDataSourceRunsRequest& request) const;
 
        template<typename ListDataSourceRunsRequestT = Model::ListDataSourceRunsRequest>
        Model::ListDataSourceRunsOutcomeCallable ListDataSourceRunsCallable(const ListDataSourceRunsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListDataSourceRuns, request);
        }
 
        template<typename ListDataSourceRunsRequestT = Model::ListDataSourceRunsRequest>
        void ListDataSourceRunsAsync(const ListDataSourceRunsRequestT& request, const ListDataSourceRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListDataSourceRuns, 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(&DataZoneClient::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(&DataZoneClient::ListDataSources, request, handler, context);
        }
 
        virtual Model::ListDomainUnitsForParentOutcome ListDomainUnitsForParent(const Model::ListDomainUnitsForParentRequest& request) const;
 
        template<typename ListDomainUnitsForParentRequestT = Model::ListDomainUnitsForParentRequest>
        Model::ListDomainUnitsForParentOutcomeCallable ListDomainUnitsForParentCallable(const ListDomainUnitsForParentRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListDomainUnitsForParent, request);
        }
 
        template<typename ListDomainUnitsForParentRequestT = Model::ListDomainUnitsForParentRequest>
        void ListDomainUnitsForParentAsync(const ListDomainUnitsForParentRequestT& request, const ListDomainUnitsForParentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListDomainUnitsForParent, request, handler, context);
        }
 
        virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request = {}) const;
 
        template<typename ListDomainsRequestT = Model::ListDomainsRequest>
        Model::ListDomainsOutcomeCallable ListDomainsCallable(const ListDomainsRequestT& request = {}) const
        {
            return SubmitCallable(&DataZoneClient::ListDomains, request);
        }
 
        template<typename ListDomainsRequestT = Model::ListDomainsRequest>
        void ListDomainsAsync(const ListDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDomainsRequestT& request = {}) const
        {
            return SubmitAsync(&DataZoneClient::ListDomains, request, handler, context);
        }
 
        virtual Model::ListEntityOwnersOutcome ListEntityOwners(const Model::ListEntityOwnersRequest& request) const;
 
        template<typename ListEntityOwnersRequestT = Model::ListEntityOwnersRequest>
        Model::ListEntityOwnersOutcomeCallable ListEntityOwnersCallable(const ListEntityOwnersRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListEntityOwners, request);
        }
 
        template<typename ListEntityOwnersRequestT = Model::ListEntityOwnersRequest>
        void ListEntityOwnersAsync(const ListEntityOwnersRequestT& request, const ListEntityOwnersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListEntityOwners, request, handler, context);
        }
 
        virtual Model::ListEnvironmentActionsOutcome ListEnvironmentActions(const Model::ListEnvironmentActionsRequest& request) const;
 
        template<typename ListEnvironmentActionsRequestT = Model::ListEnvironmentActionsRequest>
        Model::ListEnvironmentActionsOutcomeCallable ListEnvironmentActionsCallable(const ListEnvironmentActionsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListEnvironmentActions, request);
        }
 
        template<typename ListEnvironmentActionsRequestT = Model::ListEnvironmentActionsRequest>
        void ListEnvironmentActionsAsync(const ListEnvironmentActionsRequestT& request, const ListEnvironmentActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListEnvironmentActions, request, handler, context);
        }
 
        virtual Model::ListEnvironmentBlueprintConfigurationsOutcome ListEnvironmentBlueprintConfigurations(const Model::ListEnvironmentBlueprintConfigurationsRequest& request) const;
 
        template<typename ListEnvironmentBlueprintConfigurationsRequestT = Model::ListEnvironmentBlueprintConfigurationsRequest>
        Model::ListEnvironmentBlueprintConfigurationsOutcomeCallable ListEnvironmentBlueprintConfigurationsCallable(const ListEnvironmentBlueprintConfigurationsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListEnvironmentBlueprintConfigurations, request);
        }
 
        template<typename ListEnvironmentBlueprintConfigurationsRequestT = Model::ListEnvironmentBlueprintConfigurationsRequest>
        void ListEnvironmentBlueprintConfigurationsAsync(const ListEnvironmentBlueprintConfigurationsRequestT& request, const ListEnvironmentBlueprintConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListEnvironmentBlueprintConfigurations, request, handler, context);
        }
 
        virtual Model::ListEnvironmentBlueprintsOutcome ListEnvironmentBlueprints(const Model::ListEnvironmentBlueprintsRequest& request) const;
 
        template<typename ListEnvironmentBlueprintsRequestT = Model::ListEnvironmentBlueprintsRequest>
        Model::ListEnvironmentBlueprintsOutcomeCallable ListEnvironmentBlueprintsCallable(const ListEnvironmentBlueprintsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListEnvironmentBlueprints, request);
        }
 
        template<typename ListEnvironmentBlueprintsRequestT = Model::ListEnvironmentBlueprintsRequest>
        void ListEnvironmentBlueprintsAsync(const ListEnvironmentBlueprintsRequestT& request, const ListEnvironmentBlueprintsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListEnvironmentBlueprints, request, handler, context);
        }
 
        virtual Model::ListEnvironmentProfilesOutcome ListEnvironmentProfiles(const Model::ListEnvironmentProfilesRequest& request) const;
 
        template<typename ListEnvironmentProfilesRequestT = Model::ListEnvironmentProfilesRequest>
        Model::ListEnvironmentProfilesOutcomeCallable ListEnvironmentProfilesCallable(const ListEnvironmentProfilesRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListEnvironmentProfiles, request);
        }
 
        template<typename ListEnvironmentProfilesRequestT = Model::ListEnvironmentProfilesRequest>
        void ListEnvironmentProfilesAsync(const ListEnvironmentProfilesRequestT& request, const ListEnvironmentProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListEnvironmentProfiles, request, handler, context);
        }
 
        virtual Model::ListEnvironmentsOutcome ListEnvironments(const Model::ListEnvironmentsRequest& request) const;
 
        template<typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
        Model::ListEnvironmentsOutcomeCallable ListEnvironmentsCallable(const ListEnvironmentsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListEnvironments, request);
        }
 
        template<typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
        void ListEnvironmentsAsync(const ListEnvironmentsRequestT& request, const ListEnvironmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListEnvironments, request, handler, context);
        }
 
        virtual Model::ListJobRunsOutcome ListJobRuns(const Model::ListJobRunsRequest& request) const;
 
        template<typename ListJobRunsRequestT = Model::ListJobRunsRequest>
        Model::ListJobRunsOutcomeCallable ListJobRunsCallable(const ListJobRunsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListJobRuns, request);
        }
 
        template<typename ListJobRunsRequestT = Model::ListJobRunsRequest>
        void ListJobRunsAsync(const ListJobRunsRequestT& request, const ListJobRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListJobRuns, request, handler, context);
        }
 
        virtual Model::ListLineageEventsOutcome ListLineageEvents(const Model::ListLineageEventsRequest& request) const;
 
        template<typename ListLineageEventsRequestT = Model::ListLineageEventsRequest>
        Model::ListLineageEventsOutcomeCallable ListLineageEventsCallable(const ListLineageEventsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListLineageEvents, request);
        }
 
        template<typename ListLineageEventsRequestT = Model::ListLineageEventsRequest>
        void ListLineageEventsAsync(const ListLineageEventsRequestT& request, const ListLineageEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListLineageEvents, request, handler, context);
        }
 
        virtual Model::ListLineageNodeHistoryOutcome ListLineageNodeHistory(const Model::ListLineageNodeHistoryRequest& request) const;
 
        template<typename ListLineageNodeHistoryRequestT = Model::ListLineageNodeHistoryRequest>
        Model::ListLineageNodeHistoryOutcomeCallable ListLineageNodeHistoryCallable(const ListLineageNodeHistoryRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListLineageNodeHistory, request);
        }
 
        template<typename ListLineageNodeHistoryRequestT = Model::ListLineageNodeHistoryRequest>
        void ListLineageNodeHistoryAsync(const ListLineageNodeHistoryRequestT& request, const ListLineageNodeHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListLineageNodeHistory, request, handler, context);
        }
 
        virtual Model::ListMetadataGenerationRunsOutcome ListMetadataGenerationRuns(const Model::ListMetadataGenerationRunsRequest& request) const;
 
        template<typename ListMetadataGenerationRunsRequestT = Model::ListMetadataGenerationRunsRequest>
        Model::ListMetadataGenerationRunsOutcomeCallable ListMetadataGenerationRunsCallable(const ListMetadataGenerationRunsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListMetadataGenerationRuns, request);
        }
 
        template<typename ListMetadataGenerationRunsRequestT = Model::ListMetadataGenerationRunsRequest>
        void ListMetadataGenerationRunsAsync(const ListMetadataGenerationRunsRequestT& request, const ListMetadataGenerationRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListMetadataGenerationRuns, request, handler, context);
        }
 
        virtual Model::ListNotificationsOutcome ListNotifications(const Model::ListNotificationsRequest& request) const;
 
        template<typename ListNotificationsRequestT = Model::ListNotificationsRequest>
        Model::ListNotificationsOutcomeCallable ListNotificationsCallable(const ListNotificationsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListNotifications, request);
        }
 
        template<typename ListNotificationsRequestT = Model::ListNotificationsRequest>
        void ListNotificationsAsync(const ListNotificationsRequestT& request, const ListNotificationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListNotifications, request, handler, context);
        }
 
        virtual Model::ListPolicyGrantsOutcome ListPolicyGrants(const Model::ListPolicyGrantsRequest& request) const;
 
        template<typename ListPolicyGrantsRequestT = Model::ListPolicyGrantsRequest>
        Model::ListPolicyGrantsOutcomeCallable ListPolicyGrantsCallable(const ListPolicyGrantsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListPolicyGrants, request);
        }
 
        template<typename ListPolicyGrantsRequestT = Model::ListPolicyGrantsRequest>
        void ListPolicyGrantsAsync(const ListPolicyGrantsRequestT& request, const ListPolicyGrantsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListPolicyGrants, request, handler, context);
        }
 
        virtual Model::ListProjectMembershipsOutcome ListProjectMemberships(const Model::ListProjectMembershipsRequest& request) const;
 
        template<typename ListProjectMembershipsRequestT = Model::ListProjectMembershipsRequest>
        Model::ListProjectMembershipsOutcomeCallable ListProjectMembershipsCallable(const ListProjectMembershipsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListProjectMemberships, request);
        }
 
        template<typename ListProjectMembershipsRequestT = Model::ListProjectMembershipsRequest>
        void ListProjectMembershipsAsync(const ListProjectMembershipsRequestT& request, const ListProjectMembershipsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListProjectMemberships, request, handler, context);
        }
 
        virtual Model::ListProjectProfilesOutcome ListProjectProfiles(const Model::ListProjectProfilesRequest& request) const;
 
        template<typename ListProjectProfilesRequestT = Model::ListProjectProfilesRequest>
        Model::ListProjectProfilesOutcomeCallable ListProjectProfilesCallable(const ListProjectProfilesRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListProjectProfiles, request);
        }
 
        template<typename ListProjectProfilesRequestT = Model::ListProjectProfilesRequest>
        void ListProjectProfilesAsync(const ListProjectProfilesRequestT& request, const ListProjectProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListProjectProfiles, request, handler, context);
        }
 
        virtual Model::ListProjectsOutcome ListProjects(const Model::ListProjectsRequest& request) const;
 
        template<typename ListProjectsRequestT = Model::ListProjectsRequest>
        Model::ListProjectsOutcomeCallable ListProjectsCallable(const ListProjectsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListProjects, request);
        }
 
        template<typename ListProjectsRequestT = Model::ListProjectsRequest>
        void ListProjectsAsync(const ListProjectsRequestT& request, const ListProjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListProjects, request, handler, context);
        }
 
        virtual Model::ListRulesOutcome ListRules(const Model::ListRulesRequest& request) const;
 
        template<typename ListRulesRequestT = Model::ListRulesRequest>
        Model::ListRulesOutcomeCallable ListRulesCallable(const ListRulesRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListRules, request);
        }
 
        template<typename ListRulesRequestT = Model::ListRulesRequest>
        void ListRulesAsync(const ListRulesRequestT& request, const ListRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListRules, request, handler, context);
        }
 
        virtual Model::ListSubscriptionGrantsOutcome ListSubscriptionGrants(const Model::ListSubscriptionGrantsRequest& request) const;
 
        template<typename ListSubscriptionGrantsRequestT = Model::ListSubscriptionGrantsRequest>
        Model::ListSubscriptionGrantsOutcomeCallable ListSubscriptionGrantsCallable(const ListSubscriptionGrantsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListSubscriptionGrants, request);
        }
 
        template<typename ListSubscriptionGrantsRequestT = Model::ListSubscriptionGrantsRequest>
        void ListSubscriptionGrantsAsync(const ListSubscriptionGrantsRequestT& request, const ListSubscriptionGrantsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListSubscriptionGrants, request, handler, context);
        }
 
        virtual Model::ListSubscriptionRequestsOutcome ListSubscriptionRequests(const Model::ListSubscriptionRequestsRequest& request) const;
 
        template<typename ListSubscriptionRequestsRequestT = Model::ListSubscriptionRequestsRequest>
        Model::ListSubscriptionRequestsOutcomeCallable ListSubscriptionRequestsCallable(const ListSubscriptionRequestsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListSubscriptionRequests, request);
        }
 
        template<typename ListSubscriptionRequestsRequestT = Model::ListSubscriptionRequestsRequest>
        void ListSubscriptionRequestsAsync(const ListSubscriptionRequestsRequestT& request, const ListSubscriptionRequestsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListSubscriptionRequests, request, handler, context);
        }
 
        virtual Model::ListSubscriptionTargetsOutcome ListSubscriptionTargets(const Model::ListSubscriptionTargetsRequest& request) const;
 
        template<typename ListSubscriptionTargetsRequestT = Model::ListSubscriptionTargetsRequest>
        Model::ListSubscriptionTargetsOutcomeCallable ListSubscriptionTargetsCallable(const ListSubscriptionTargetsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListSubscriptionTargets, request);
        }
 
        template<typename ListSubscriptionTargetsRequestT = Model::ListSubscriptionTargetsRequest>
        void ListSubscriptionTargetsAsync(const ListSubscriptionTargetsRequestT& request, const ListSubscriptionTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListSubscriptionTargets, request, handler, context);
        }
 
        virtual Model::ListSubscriptionsOutcome ListSubscriptions(const Model::ListSubscriptionsRequest& request) const;
 
        template<typename ListSubscriptionsRequestT = Model::ListSubscriptionsRequest>
        Model::ListSubscriptionsOutcomeCallable ListSubscriptionsCallable(const ListSubscriptionsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListSubscriptions, request);
        }
 
        template<typename ListSubscriptionsRequestT = Model::ListSubscriptionsRequest>
        void ListSubscriptionsAsync(const ListSubscriptionsRequestT& request, const ListSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListSubscriptions, 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(&DataZoneClient::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(&DataZoneClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTimeSeriesDataPointsOutcome ListTimeSeriesDataPoints(const Model::ListTimeSeriesDataPointsRequest& request) const;
 
        template<typename ListTimeSeriesDataPointsRequestT = Model::ListTimeSeriesDataPointsRequest>
        Model::ListTimeSeriesDataPointsOutcomeCallable ListTimeSeriesDataPointsCallable(const ListTimeSeriesDataPointsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::ListTimeSeriesDataPoints, request);
        }
 
        template<typename ListTimeSeriesDataPointsRequestT = Model::ListTimeSeriesDataPointsRequest>
        void ListTimeSeriesDataPointsAsync(const ListTimeSeriesDataPointsRequestT& request, const ListTimeSeriesDataPointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::ListTimeSeriesDataPoints, request, handler, context);
        }
 
        virtual Model::PostLineageEventOutcome PostLineageEvent(const Model::PostLineageEventRequest& request) const;
 
        template<typename PostLineageEventRequestT = Model::PostLineageEventRequest>
        Model::PostLineageEventOutcomeCallable PostLineageEventCallable(const PostLineageEventRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::PostLineageEvent, request);
        }
 
        template<typename PostLineageEventRequestT = Model::PostLineageEventRequest>
        void PostLineageEventAsync(const PostLineageEventRequestT& request, const PostLineageEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::PostLineageEvent, request, handler, context);
        }
 
        virtual Model::PostTimeSeriesDataPointsOutcome PostTimeSeriesDataPoints(const Model::PostTimeSeriesDataPointsRequest& request) const;
 
        template<typename PostTimeSeriesDataPointsRequestT = Model::PostTimeSeriesDataPointsRequest>
        Model::PostTimeSeriesDataPointsOutcomeCallable PostTimeSeriesDataPointsCallable(const PostTimeSeriesDataPointsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::PostTimeSeriesDataPoints, request);
        }
 
        template<typename PostTimeSeriesDataPointsRequestT = Model::PostTimeSeriesDataPointsRequest>
        void PostTimeSeriesDataPointsAsync(const PostTimeSeriesDataPointsRequestT& request, const PostTimeSeriesDataPointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::PostTimeSeriesDataPoints, request, handler, context);
        }
 
        virtual Model::PutEnvironmentBlueprintConfigurationOutcome PutEnvironmentBlueprintConfiguration(const Model::PutEnvironmentBlueprintConfigurationRequest& request) const;
 
        template<typename PutEnvironmentBlueprintConfigurationRequestT = Model::PutEnvironmentBlueprintConfigurationRequest>
        Model::PutEnvironmentBlueprintConfigurationOutcomeCallable PutEnvironmentBlueprintConfigurationCallable(const PutEnvironmentBlueprintConfigurationRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::PutEnvironmentBlueprintConfiguration, request);
        }
 
        template<typename PutEnvironmentBlueprintConfigurationRequestT = Model::PutEnvironmentBlueprintConfigurationRequest>
        void PutEnvironmentBlueprintConfigurationAsync(const PutEnvironmentBlueprintConfigurationRequestT& request, const PutEnvironmentBlueprintConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::PutEnvironmentBlueprintConfiguration, request, handler, context);
        }
 
        virtual Model::RejectPredictionsOutcome RejectPredictions(const Model::RejectPredictionsRequest& request) const;
 
        template<typename RejectPredictionsRequestT = Model::RejectPredictionsRequest>
        Model::RejectPredictionsOutcomeCallable RejectPredictionsCallable(const RejectPredictionsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::RejectPredictions, request);
        }
 
        template<typename RejectPredictionsRequestT = Model::RejectPredictionsRequest>
        void RejectPredictionsAsync(const RejectPredictionsRequestT& request, const RejectPredictionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::RejectPredictions, request, handler, context);
        }
 
        virtual Model::RejectSubscriptionRequestOutcome RejectSubscriptionRequest(const Model::RejectSubscriptionRequestRequest& request) const;
 
        template<typename RejectSubscriptionRequestRequestT = Model::RejectSubscriptionRequestRequest>
        Model::RejectSubscriptionRequestOutcomeCallable RejectSubscriptionRequestCallable(const RejectSubscriptionRequestRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::RejectSubscriptionRequest, request);
        }
 
        template<typename RejectSubscriptionRequestRequestT = Model::RejectSubscriptionRequestRequest>
        void RejectSubscriptionRequestAsync(const RejectSubscriptionRequestRequestT& request, const RejectSubscriptionRequestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::RejectSubscriptionRequest, request, handler, context);
        }
 
        virtual Model::RemoveEntityOwnerOutcome RemoveEntityOwner(const Model::RemoveEntityOwnerRequest& request) const;
 
        template<typename RemoveEntityOwnerRequestT = Model::RemoveEntityOwnerRequest>
        Model::RemoveEntityOwnerOutcomeCallable RemoveEntityOwnerCallable(const RemoveEntityOwnerRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::RemoveEntityOwner, request);
        }
 
        template<typename RemoveEntityOwnerRequestT = Model::RemoveEntityOwnerRequest>
        void RemoveEntityOwnerAsync(const RemoveEntityOwnerRequestT& request, const RemoveEntityOwnerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::RemoveEntityOwner, request, handler, context);
        }
 
        virtual Model::RemovePolicyGrantOutcome RemovePolicyGrant(const Model::RemovePolicyGrantRequest& request) const;
 
        template<typename RemovePolicyGrantRequestT = Model::RemovePolicyGrantRequest>
        Model::RemovePolicyGrantOutcomeCallable RemovePolicyGrantCallable(const RemovePolicyGrantRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::RemovePolicyGrant, request);
        }
 
        template<typename RemovePolicyGrantRequestT = Model::RemovePolicyGrantRequest>
        void RemovePolicyGrantAsync(const RemovePolicyGrantRequestT& request, const RemovePolicyGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::RemovePolicyGrant, request, handler, context);
        }
 
        virtual Model::RevokeSubscriptionOutcome RevokeSubscription(const Model::RevokeSubscriptionRequest& request) const;
 
        template<typename RevokeSubscriptionRequestT = Model::RevokeSubscriptionRequest>
        Model::RevokeSubscriptionOutcomeCallable RevokeSubscriptionCallable(const RevokeSubscriptionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::RevokeSubscription, request);
        }
 
        template<typename RevokeSubscriptionRequestT = Model::RevokeSubscriptionRequest>
        void RevokeSubscriptionAsync(const RevokeSubscriptionRequestT& request, const RevokeSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::RevokeSubscription, request, handler, context);
        }
 
        virtual Model::SearchOutcome Search(const Model::SearchRequest& request) const;
 
        template<typename SearchRequestT = Model::SearchRequest>
        Model::SearchOutcomeCallable SearchCallable(const SearchRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::Search, request);
        }
 
        template<typename SearchRequestT = Model::SearchRequest>
        void SearchAsync(const SearchRequestT& request, const SearchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::Search, request, handler, context);
        }
 
        virtual Model::SearchGroupProfilesOutcome SearchGroupProfiles(const Model::SearchGroupProfilesRequest& request) const;
 
        template<typename SearchGroupProfilesRequestT = Model::SearchGroupProfilesRequest>
        Model::SearchGroupProfilesOutcomeCallable SearchGroupProfilesCallable(const SearchGroupProfilesRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::SearchGroupProfiles, request);
        }
 
        template<typename SearchGroupProfilesRequestT = Model::SearchGroupProfilesRequest>
        void SearchGroupProfilesAsync(const SearchGroupProfilesRequestT& request, const SearchGroupProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::SearchGroupProfiles, request, handler, context);
        }
 
        virtual Model::SearchListingsOutcome SearchListings(const Model::SearchListingsRequest& request) const;
 
        template<typename SearchListingsRequestT = Model::SearchListingsRequest>
        Model::SearchListingsOutcomeCallable SearchListingsCallable(const SearchListingsRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::SearchListings, request);
        }
 
        template<typename SearchListingsRequestT = Model::SearchListingsRequest>
        void SearchListingsAsync(const SearchListingsRequestT& request, const SearchListingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::SearchListings, request, handler, context);
        }
 
        virtual Model::SearchTypesOutcome SearchTypes(const Model::SearchTypesRequest& request) const;
 
        template<typename SearchTypesRequestT = Model::SearchTypesRequest>
        Model::SearchTypesOutcomeCallable SearchTypesCallable(const SearchTypesRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::SearchTypes, request);
        }
 
        template<typename SearchTypesRequestT = Model::SearchTypesRequest>
        void SearchTypesAsync(const SearchTypesRequestT& request, const SearchTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::SearchTypes, request, handler, context);
        }
 
        virtual Model::SearchUserProfilesOutcome SearchUserProfiles(const Model::SearchUserProfilesRequest& request) const;
 
        template<typename SearchUserProfilesRequestT = Model::SearchUserProfilesRequest>
        Model::SearchUserProfilesOutcomeCallable SearchUserProfilesCallable(const SearchUserProfilesRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::SearchUserProfiles, request);
        }
 
        template<typename SearchUserProfilesRequestT = Model::SearchUserProfilesRequest>
        void SearchUserProfilesAsync(const SearchUserProfilesRequestT& request, const SearchUserProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::SearchUserProfiles, request, handler, context);
        }
 
        virtual Model::StartDataSourceRunOutcome StartDataSourceRun(const Model::StartDataSourceRunRequest& request) const;
 
        template<typename StartDataSourceRunRequestT = Model::StartDataSourceRunRequest>
        Model::StartDataSourceRunOutcomeCallable StartDataSourceRunCallable(const StartDataSourceRunRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::StartDataSourceRun, request);
        }
 
        template<typename StartDataSourceRunRequestT = Model::StartDataSourceRunRequest>
        void StartDataSourceRunAsync(const StartDataSourceRunRequestT& request, const StartDataSourceRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::StartDataSourceRun, request, handler, context);
        }
 
        virtual Model::StartMetadataGenerationRunOutcome StartMetadataGenerationRun(const Model::StartMetadataGenerationRunRequest& request) const;
 
        template<typename StartMetadataGenerationRunRequestT = Model::StartMetadataGenerationRunRequest>
        Model::StartMetadataGenerationRunOutcomeCallable StartMetadataGenerationRunCallable(const StartMetadataGenerationRunRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::StartMetadataGenerationRun, request);
        }
 
        template<typename StartMetadataGenerationRunRequestT = Model::StartMetadataGenerationRunRequest>
        void StartMetadataGenerationRunAsync(const StartMetadataGenerationRunRequestT& request, const StartMetadataGenerationRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::StartMetadataGenerationRun, 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(&DataZoneClient::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(&DataZoneClient::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(&DataZoneClient::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(&DataZoneClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAccountPoolOutcome UpdateAccountPool(const Model::UpdateAccountPoolRequest& request) const;
 
        template<typename UpdateAccountPoolRequestT = Model::UpdateAccountPoolRequest>
        Model::UpdateAccountPoolOutcomeCallable UpdateAccountPoolCallable(const UpdateAccountPoolRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateAccountPool, request);
        }
 
        template<typename UpdateAccountPoolRequestT = Model::UpdateAccountPoolRequest>
        void UpdateAccountPoolAsync(const UpdateAccountPoolRequestT& request, const UpdateAccountPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateAccountPool, request, handler, context);
        }
 
        virtual Model::UpdateAssetFilterOutcome UpdateAssetFilter(const Model::UpdateAssetFilterRequest& request) const;
 
        template<typename UpdateAssetFilterRequestT = Model::UpdateAssetFilterRequest>
        Model::UpdateAssetFilterOutcomeCallable UpdateAssetFilterCallable(const UpdateAssetFilterRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateAssetFilter, request);
        }
 
        template<typename UpdateAssetFilterRequestT = Model::UpdateAssetFilterRequest>
        void UpdateAssetFilterAsync(const UpdateAssetFilterRequestT& request, const UpdateAssetFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateAssetFilter, request, handler, context);
        }
 
        virtual Model::UpdateConnectionOutcome UpdateConnection(const Model::UpdateConnectionRequest& request) const;
 
        template<typename UpdateConnectionRequestT = Model::UpdateConnectionRequest>
        Model::UpdateConnectionOutcomeCallable UpdateConnectionCallable(const UpdateConnectionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateConnection, request);
        }
 
        template<typename UpdateConnectionRequestT = Model::UpdateConnectionRequest>
        void UpdateConnectionAsync(const UpdateConnectionRequestT& request, const UpdateConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateConnection, 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(&DataZoneClient::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(&DataZoneClient::UpdateDataSource, request, handler, context);
        }
 
        virtual Model::UpdateDomainOutcome UpdateDomain(const Model::UpdateDomainRequest& request) const;
 
        template<typename UpdateDomainRequestT = Model::UpdateDomainRequest>
        Model::UpdateDomainOutcomeCallable UpdateDomainCallable(const UpdateDomainRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateDomain, request);
        }
 
        template<typename UpdateDomainRequestT = Model::UpdateDomainRequest>
        void UpdateDomainAsync(const UpdateDomainRequestT& request, const UpdateDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateDomain, request, handler, context);
        }
 
        virtual Model::UpdateDomainUnitOutcome UpdateDomainUnit(const Model::UpdateDomainUnitRequest& request) const;
 
        template<typename UpdateDomainUnitRequestT = Model::UpdateDomainUnitRequest>
        Model::UpdateDomainUnitOutcomeCallable UpdateDomainUnitCallable(const UpdateDomainUnitRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateDomainUnit, request);
        }
 
        template<typename UpdateDomainUnitRequestT = Model::UpdateDomainUnitRequest>
        void UpdateDomainUnitAsync(const UpdateDomainUnitRequestT& request, const UpdateDomainUnitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateDomainUnit, request, handler, context);
        }
 
        virtual Model::UpdateEnvironmentOutcome UpdateEnvironment(const Model::UpdateEnvironmentRequest& request) const;
 
        template<typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
        Model::UpdateEnvironmentOutcomeCallable UpdateEnvironmentCallable(const UpdateEnvironmentRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateEnvironment, request);
        }
 
        template<typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
        void UpdateEnvironmentAsync(const UpdateEnvironmentRequestT& request, const UpdateEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateEnvironment, request, handler, context);
        }
 
        virtual Model::UpdateEnvironmentActionOutcome UpdateEnvironmentAction(const Model::UpdateEnvironmentActionRequest& request) const;
 
        template<typename UpdateEnvironmentActionRequestT = Model::UpdateEnvironmentActionRequest>
        Model::UpdateEnvironmentActionOutcomeCallable UpdateEnvironmentActionCallable(const UpdateEnvironmentActionRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateEnvironmentAction, request);
        }
 
        template<typename UpdateEnvironmentActionRequestT = Model::UpdateEnvironmentActionRequest>
        void UpdateEnvironmentActionAsync(const UpdateEnvironmentActionRequestT& request, const UpdateEnvironmentActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateEnvironmentAction, request, handler, context);
        }
 
        virtual Model::UpdateEnvironmentProfileOutcome UpdateEnvironmentProfile(const Model::UpdateEnvironmentProfileRequest& request) const;
 
        template<typename UpdateEnvironmentProfileRequestT = Model::UpdateEnvironmentProfileRequest>
        Model::UpdateEnvironmentProfileOutcomeCallable UpdateEnvironmentProfileCallable(const UpdateEnvironmentProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateEnvironmentProfile, request);
        }
 
        template<typename UpdateEnvironmentProfileRequestT = Model::UpdateEnvironmentProfileRequest>
        void UpdateEnvironmentProfileAsync(const UpdateEnvironmentProfileRequestT& request, const UpdateEnvironmentProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateEnvironmentProfile, request, handler, context);
        }
 
        virtual Model::UpdateGlossaryOutcome UpdateGlossary(const Model::UpdateGlossaryRequest& request) const;
 
        template<typename UpdateGlossaryRequestT = Model::UpdateGlossaryRequest>
        Model::UpdateGlossaryOutcomeCallable UpdateGlossaryCallable(const UpdateGlossaryRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateGlossary, request);
        }
 
        template<typename UpdateGlossaryRequestT = Model::UpdateGlossaryRequest>
        void UpdateGlossaryAsync(const UpdateGlossaryRequestT& request, const UpdateGlossaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateGlossary, request, handler, context);
        }
 
        virtual Model::UpdateGlossaryTermOutcome UpdateGlossaryTerm(const Model::UpdateGlossaryTermRequest& request) const;
 
        template<typename UpdateGlossaryTermRequestT = Model::UpdateGlossaryTermRequest>
        Model::UpdateGlossaryTermOutcomeCallable UpdateGlossaryTermCallable(const UpdateGlossaryTermRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateGlossaryTerm, request);
        }
 
        template<typename UpdateGlossaryTermRequestT = Model::UpdateGlossaryTermRequest>
        void UpdateGlossaryTermAsync(const UpdateGlossaryTermRequestT& request, const UpdateGlossaryTermResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateGlossaryTerm, request, handler, context);
        }
 
        virtual Model::UpdateGroupProfileOutcome UpdateGroupProfile(const Model::UpdateGroupProfileRequest& request) const;
 
        template<typename UpdateGroupProfileRequestT = Model::UpdateGroupProfileRequest>
        Model::UpdateGroupProfileOutcomeCallable UpdateGroupProfileCallable(const UpdateGroupProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateGroupProfile, request);
        }
 
        template<typename UpdateGroupProfileRequestT = Model::UpdateGroupProfileRequest>
        void UpdateGroupProfileAsync(const UpdateGroupProfileRequestT& request, const UpdateGroupProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateGroupProfile, request, handler, context);
        }
 
        virtual Model::UpdateProjectOutcome UpdateProject(const Model::UpdateProjectRequest& request) const;
 
        template<typename UpdateProjectRequestT = Model::UpdateProjectRequest>
        Model::UpdateProjectOutcomeCallable UpdateProjectCallable(const UpdateProjectRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateProject, request);
        }
 
        template<typename UpdateProjectRequestT = Model::UpdateProjectRequest>
        void UpdateProjectAsync(const UpdateProjectRequestT& request, const UpdateProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateProject, request, handler, context);
        }
 
        virtual Model::UpdateProjectProfileOutcome UpdateProjectProfile(const Model::UpdateProjectProfileRequest& request) const;
 
        template<typename UpdateProjectProfileRequestT = Model::UpdateProjectProfileRequest>
        Model::UpdateProjectProfileOutcomeCallable UpdateProjectProfileCallable(const UpdateProjectProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateProjectProfile, request);
        }
 
        template<typename UpdateProjectProfileRequestT = Model::UpdateProjectProfileRequest>
        void UpdateProjectProfileAsync(const UpdateProjectProfileRequestT& request, const UpdateProjectProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateProjectProfile, request, handler, context);
        }
 
        virtual Model::UpdateRuleOutcome UpdateRule(const Model::UpdateRuleRequest& request) const;
 
        template<typename UpdateRuleRequestT = Model::UpdateRuleRequest>
        Model::UpdateRuleOutcomeCallable UpdateRuleCallable(const UpdateRuleRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateRule, request);
        }
 
        template<typename UpdateRuleRequestT = Model::UpdateRuleRequest>
        void UpdateRuleAsync(const UpdateRuleRequestT& request, const UpdateRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateRule, request, handler, context);
        }
 
        virtual Model::UpdateSubscriptionGrantStatusOutcome UpdateSubscriptionGrantStatus(const Model::UpdateSubscriptionGrantStatusRequest& request) const;
 
        template<typename UpdateSubscriptionGrantStatusRequestT = Model::UpdateSubscriptionGrantStatusRequest>
        Model::UpdateSubscriptionGrantStatusOutcomeCallable UpdateSubscriptionGrantStatusCallable(const UpdateSubscriptionGrantStatusRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateSubscriptionGrantStatus, request);
        }
 
        template<typename UpdateSubscriptionGrantStatusRequestT = Model::UpdateSubscriptionGrantStatusRequest>
        void UpdateSubscriptionGrantStatusAsync(const UpdateSubscriptionGrantStatusRequestT& request, const UpdateSubscriptionGrantStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateSubscriptionGrantStatus, request, handler, context);
        }
 
        virtual Model::UpdateSubscriptionRequestOutcome UpdateSubscriptionRequest(const Model::UpdateSubscriptionRequestRequest& request) const;
 
        template<typename UpdateSubscriptionRequestRequestT = Model::UpdateSubscriptionRequestRequest>
        Model::UpdateSubscriptionRequestOutcomeCallable UpdateSubscriptionRequestCallable(const UpdateSubscriptionRequestRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateSubscriptionRequest, request);
        }
 
        template<typename UpdateSubscriptionRequestRequestT = Model::UpdateSubscriptionRequestRequest>
        void UpdateSubscriptionRequestAsync(const UpdateSubscriptionRequestRequestT& request, const UpdateSubscriptionRequestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateSubscriptionRequest, request, handler, context);
        }
 
        virtual Model::UpdateSubscriptionTargetOutcome UpdateSubscriptionTarget(const Model::UpdateSubscriptionTargetRequest& request) const;
 
        template<typename UpdateSubscriptionTargetRequestT = Model::UpdateSubscriptionTargetRequest>
        Model::UpdateSubscriptionTargetOutcomeCallable UpdateSubscriptionTargetCallable(const UpdateSubscriptionTargetRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateSubscriptionTarget, request);
        }
 
        template<typename UpdateSubscriptionTargetRequestT = Model::UpdateSubscriptionTargetRequest>
        void UpdateSubscriptionTargetAsync(const UpdateSubscriptionTargetRequestT& request, const UpdateSubscriptionTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateSubscriptionTarget, request, handler, context);
        }
 
        virtual Model::UpdateUserProfileOutcome UpdateUserProfile(const Model::UpdateUserProfileRequest& request) const;
 
        template<typename UpdateUserProfileRequestT = Model::UpdateUserProfileRequest>
        Model::UpdateUserProfileOutcomeCallable UpdateUserProfileCallable(const UpdateUserProfileRequestT& request) const
        {
            return SubmitCallable(&DataZoneClient::UpdateUserProfile, request);
        }
 
        template<typename UpdateUserProfileRequestT = Model::UpdateUserProfileRequest>
        void UpdateUserProfileAsync(const UpdateUserProfileRequestT& request, const UpdateUserProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataZoneClient::UpdateUserProfile, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<DataZoneEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<DataZoneClient>;
      void init(const DataZoneClientConfiguration& clientConfiguration);
 
      DataZoneClientConfiguration m_clientConfiguration;
      std::shared_ptr<DataZoneEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace DataZone
} // namespace Aws