DataZoneClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/datazone/DataZonePaginationBase.h>
#include <aws/datazone/DataZoneServiceClientModel.h>
#include <aws/datazone/DataZoneWaiter.h>
#include <aws/datazone/DataZone_EXPORTS.h>
 
namespace Aws {
namespace DataZone {
class AWS_DATAZONE_API DataZoneClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<DataZoneClient>,
                                        public DataZonePaginationBase<DataZoneClient>,
                                        public DataZoneWaiter<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::BatchGetAttributesMetadataOutcome BatchGetAttributesMetadata(
      const Model::BatchGetAttributesMetadataRequest& request) const;
 
  template <typename BatchGetAttributesMetadataRequestT = Model::BatchGetAttributesMetadataRequest>
  Model::BatchGetAttributesMetadataOutcomeCallable BatchGetAttributesMetadataCallable(
      const BatchGetAttributesMetadataRequestT& request) const {
    return SubmitCallable(&DataZoneClient::BatchGetAttributesMetadata, request);
  }
 
  template <typename BatchGetAttributesMetadataRequestT = Model::BatchGetAttributesMetadataRequest>
  void BatchGetAttributesMetadataAsync(const BatchGetAttributesMetadataRequestT& request,
                                       const BatchGetAttributesMetadataResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::BatchGetAttributesMetadata, request, handler, context);
  }
 
  virtual Model::BatchPutAttributesMetadataOutcome BatchPutAttributesMetadata(
      const Model::BatchPutAttributesMetadataRequest& request) const;
 
  template <typename BatchPutAttributesMetadataRequestT = Model::BatchPutAttributesMetadataRequest>
  Model::BatchPutAttributesMetadataOutcomeCallable BatchPutAttributesMetadataCallable(
      const BatchPutAttributesMetadataRequestT& request) const {
    return SubmitCallable(&DataZoneClient::BatchPutAttributesMetadata, request);
  }
 
  template <typename BatchPutAttributesMetadataRequestT = Model::BatchPutAttributesMetadataRequest>
  void BatchPutAttributesMetadataAsync(const BatchPutAttributesMetadataRequestT& request,
                                       const BatchPutAttributesMetadataResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::BatchPutAttributesMetadata, 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::CreateEnvironmentBlueprintOutcome CreateEnvironmentBlueprint(
      const Model::CreateEnvironmentBlueprintRequest& request) const;
 
  template <typename CreateEnvironmentBlueprintRequestT = Model::CreateEnvironmentBlueprintRequest>
  Model::CreateEnvironmentBlueprintOutcomeCallable CreateEnvironmentBlueprintCallable(
      const CreateEnvironmentBlueprintRequestT& request) const {
    return SubmitCallable(&DataZoneClient::CreateEnvironmentBlueprint, request);
  }
 
  template <typename CreateEnvironmentBlueprintRequestT = Model::CreateEnvironmentBlueprintRequest>
  void CreateEnvironmentBlueprintAsync(const CreateEnvironmentBlueprintRequestT& request,
                                       const CreateEnvironmentBlueprintResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::CreateEnvironmentBlueprint, 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::CreateNotebookOutcome CreateNotebook(const Model::CreateNotebookRequest& request) const;
 
  template <typename CreateNotebookRequestT = Model::CreateNotebookRequest>
  Model::CreateNotebookOutcomeCallable CreateNotebookCallable(const CreateNotebookRequestT& request) const {
    return SubmitCallable(&DataZoneClient::CreateNotebook, request);
  }
 
  template <typename CreateNotebookRequestT = Model::CreateNotebookRequest>
  void CreateNotebookAsync(const CreateNotebookRequestT& request, const CreateNotebookResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::CreateNotebook, 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::DeleteDataExportConfigurationOutcome DeleteDataExportConfiguration(
      const Model::DeleteDataExportConfigurationRequest& request) const;
 
  template <typename DeleteDataExportConfigurationRequestT = Model::DeleteDataExportConfigurationRequest>
  Model::DeleteDataExportConfigurationOutcomeCallable DeleteDataExportConfigurationCallable(
      const DeleteDataExportConfigurationRequestT& request) const {
    return SubmitCallable(&DataZoneClient::DeleteDataExportConfiguration, request);
  }
 
  template <typename DeleteDataExportConfigurationRequestT = Model::DeleteDataExportConfigurationRequest>
  void DeleteDataExportConfigurationAsync(const DeleteDataExportConfigurationRequestT& request,
                                          const DeleteDataExportConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::DeleteDataExportConfiguration, 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::DeleteEnvironmentBlueprintOutcome DeleteEnvironmentBlueprint(
      const Model::DeleteEnvironmentBlueprintRequest& request) const;
 
  template <typename DeleteEnvironmentBlueprintRequestT = Model::DeleteEnvironmentBlueprintRequest>
  Model::DeleteEnvironmentBlueprintOutcomeCallable DeleteEnvironmentBlueprintCallable(
      const DeleteEnvironmentBlueprintRequestT& request) const {
    return SubmitCallable(&DataZoneClient::DeleteEnvironmentBlueprint, request);
  }
 
  template <typename DeleteEnvironmentBlueprintRequestT = Model::DeleteEnvironmentBlueprintRequest>
  void DeleteEnvironmentBlueprintAsync(const DeleteEnvironmentBlueprintRequestT& request,
                                       const DeleteEnvironmentBlueprintResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::DeleteEnvironmentBlueprint, 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::DeleteLineageEventOutcome DeleteLineageEvent(const Model::DeleteLineageEventRequest& request) const;
 
  template <typename DeleteLineageEventRequestT = Model::DeleteLineageEventRequest>
  Model::DeleteLineageEventOutcomeCallable DeleteLineageEventCallable(const DeleteLineageEventRequestT& request) const {
    return SubmitCallable(&DataZoneClient::DeleteLineageEvent, request);
  }
 
  template <typename DeleteLineageEventRequestT = Model::DeleteLineageEventRequest>
  void DeleteLineageEventAsync(const DeleteLineageEventRequestT& request, const DeleteLineageEventResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::DeleteLineageEvent, 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::DeleteNotebookOutcome DeleteNotebook(const Model::DeleteNotebookRequest& request) const;
 
  template <typename DeleteNotebookRequestT = Model::DeleteNotebookRequest>
  Model::DeleteNotebookOutcomeCallable DeleteNotebookCallable(const DeleteNotebookRequestT& request) const {
    return SubmitCallable(&DataZoneClient::DeleteNotebook, request);
  }
 
  template <typename DeleteNotebookRequestT = Model::DeleteNotebookRequest>
  void DeleteNotebookAsync(const DeleteNotebookRequestT& request, const DeleteNotebookResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::DeleteNotebook, 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::GetDataExportConfigurationOutcome GetDataExportConfiguration(
      const Model::GetDataExportConfigurationRequest& request) const;
 
  template <typename GetDataExportConfigurationRequestT = Model::GetDataExportConfigurationRequest>
  Model::GetDataExportConfigurationOutcomeCallable GetDataExportConfigurationCallable(
      const GetDataExportConfigurationRequestT& request) const {
    return SubmitCallable(&DataZoneClient::GetDataExportConfiguration, request);
  }
 
  template <typename GetDataExportConfigurationRequestT = Model::GetDataExportConfigurationRequest>
  void GetDataExportConfigurationAsync(const GetDataExportConfigurationRequestT& request,
                                       const GetDataExportConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::GetDataExportConfiguration, 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::GetNotebookOutcome GetNotebook(const Model::GetNotebookRequest& request) const;
 
  template <typename GetNotebookRequestT = Model::GetNotebookRequest>
  Model::GetNotebookOutcomeCallable GetNotebookCallable(const GetNotebookRequestT& request) const {
    return SubmitCallable(&DataZoneClient::GetNotebook, request);
  }
 
  template <typename GetNotebookRequestT = Model::GetNotebookRequest>
  void GetNotebookAsync(const GetNotebookRequestT& request, const GetNotebookResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::GetNotebook, request, handler, context);
  }
 
  virtual Model::GetNotebookExportOutcome GetNotebookExport(const Model::GetNotebookExportRequest& request) const;
 
  template <typename GetNotebookExportRequestT = Model::GetNotebookExportRequest>
  Model::GetNotebookExportOutcomeCallable GetNotebookExportCallable(const GetNotebookExportRequestT& request) const {
    return SubmitCallable(&DataZoneClient::GetNotebookExport, request);
  }
 
  template <typename GetNotebookExportRequestT = Model::GetNotebookExportRequest>
  void GetNotebookExportAsync(const GetNotebookExportRequestT& request, const GetNotebookExportResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::GetNotebookExport, request, handler, context);
  }
 
  virtual Model::GetNotebookRunOutcome GetNotebookRun(const Model::GetNotebookRunRequest& request) const;
 
  template <typename GetNotebookRunRequestT = Model::GetNotebookRunRequest>
  Model::GetNotebookRunOutcomeCallable GetNotebookRunCallable(const GetNotebookRunRequestT& request) const {
    return SubmitCallable(&DataZoneClient::GetNotebookRun, request);
  }
 
  template <typename GetNotebookRunRequestT = Model::GetNotebookRunRequest>
  void GetNotebookRunAsync(const GetNotebookRunRequestT& request, const GetNotebookRunResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::GetNotebookRun, 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::ListNotebookRunsOutcome ListNotebookRuns(const Model::ListNotebookRunsRequest& request) const;
 
  template <typename ListNotebookRunsRequestT = Model::ListNotebookRunsRequest>
  Model::ListNotebookRunsOutcomeCallable ListNotebookRunsCallable(const ListNotebookRunsRequestT& request) const {
    return SubmitCallable(&DataZoneClient::ListNotebookRuns, request);
  }
 
  template <typename ListNotebookRunsRequestT = Model::ListNotebookRunsRequest>
  void ListNotebookRunsAsync(const ListNotebookRunsRequestT& request, const ListNotebookRunsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::ListNotebookRuns, request, handler, context);
  }
 
  virtual Model::ListNotebooksOutcome ListNotebooks(const Model::ListNotebooksRequest& request) const;
 
  template <typename ListNotebooksRequestT = Model::ListNotebooksRequest>
  Model::ListNotebooksOutcomeCallable ListNotebooksCallable(const ListNotebooksRequestT& request) const {
    return SubmitCallable(&DataZoneClient::ListNotebooks, request);
  }
 
  template <typename ListNotebooksRequestT = Model::ListNotebooksRequest>
  void ListNotebooksAsync(const ListNotebooksRequestT& request, const ListNotebooksResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::ListNotebooks, 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::PutDataExportConfigurationOutcome PutDataExportConfiguration(
      const Model::PutDataExportConfigurationRequest& request) const;
 
  template <typename PutDataExportConfigurationRequestT = Model::PutDataExportConfigurationRequest>
  Model::PutDataExportConfigurationOutcomeCallable PutDataExportConfigurationCallable(
      const PutDataExportConfigurationRequestT& request) const {
    return SubmitCallable(&DataZoneClient::PutDataExportConfiguration, request);
  }
 
  template <typename PutDataExportConfigurationRequestT = Model::PutDataExportConfigurationRequest>
  void PutDataExportConfigurationAsync(const PutDataExportConfigurationRequestT& request,
                                       const PutDataExportConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::PutDataExportConfiguration, 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::QueryGraphOutcome QueryGraph(const Model::QueryGraphRequest& request) const;
 
  template <typename QueryGraphRequestT = Model::QueryGraphRequest>
  Model::QueryGraphOutcomeCallable QueryGraphCallable(const QueryGraphRequestT& request) const {
    return SubmitCallable(&DataZoneClient::QueryGraph, request);
  }
 
  template <typename QueryGraphRequestT = Model::QueryGraphRequest>
  void QueryGraphAsync(const QueryGraphRequestT& request, const QueryGraphResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::QueryGraph, 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::StartNotebookExportOutcome StartNotebookExport(const Model::StartNotebookExportRequest& request) const;
 
  template <typename StartNotebookExportRequestT = Model::StartNotebookExportRequest>
  Model::StartNotebookExportOutcomeCallable StartNotebookExportCallable(const StartNotebookExportRequestT& request) const {
    return SubmitCallable(&DataZoneClient::StartNotebookExport, request);
  }
 
  template <typename StartNotebookExportRequestT = Model::StartNotebookExportRequest>
  void StartNotebookExportAsync(const StartNotebookExportRequestT& request, const StartNotebookExportResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::StartNotebookExport, request, handler, context);
  }
 
  virtual Model::StartNotebookImportOutcome StartNotebookImport(const Model::StartNotebookImportRequest& request) const;
 
  template <typename StartNotebookImportRequestT = Model::StartNotebookImportRequest>
  Model::StartNotebookImportOutcomeCallable StartNotebookImportCallable(const StartNotebookImportRequestT& request) const {
    return SubmitCallable(&DataZoneClient::StartNotebookImport, request);
  }
 
  template <typename StartNotebookImportRequestT = Model::StartNotebookImportRequest>
  void StartNotebookImportAsync(const StartNotebookImportRequestT& request, const StartNotebookImportResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::StartNotebookImport, request, handler, context);
  }
 
  virtual Model::StartNotebookRunOutcome StartNotebookRun(const Model::StartNotebookRunRequest& request) const;
 
  template <typename StartNotebookRunRequestT = Model::StartNotebookRunRequest>
  Model::StartNotebookRunOutcomeCallable StartNotebookRunCallable(const StartNotebookRunRequestT& request) const {
    return SubmitCallable(&DataZoneClient::StartNotebookRun, request);
  }
 
  template <typename StartNotebookRunRequestT = Model::StartNotebookRunRequest>
  void StartNotebookRunAsync(const StartNotebookRunRequestT& request, const StartNotebookRunResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::StartNotebookRun, request, handler, context);
  }
 
  virtual Model::StopNotebookRunOutcome StopNotebookRun(const Model::StopNotebookRunRequest& request) const;
 
  template <typename StopNotebookRunRequestT = Model::StopNotebookRunRequest>
  Model::StopNotebookRunOutcomeCallable StopNotebookRunCallable(const StopNotebookRunRequestT& request) const {
    return SubmitCallable(&DataZoneClient::StopNotebookRun, request);
  }
 
  template <typename StopNotebookRunRequestT = Model::StopNotebookRunRequest>
  void StopNotebookRunAsync(const StopNotebookRunRequestT& request, const StopNotebookRunResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::StopNotebookRun, 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::UpdateEnvironmentBlueprintOutcome UpdateEnvironmentBlueprint(
      const Model::UpdateEnvironmentBlueprintRequest& request) const;
 
  template <typename UpdateEnvironmentBlueprintRequestT = Model::UpdateEnvironmentBlueprintRequest>
  Model::UpdateEnvironmentBlueprintOutcomeCallable UpdateEnvironmentBlueprintCallable(
      const UpdateEnvironmentBlueprintRequestT& request) const {
    return SubmitCallable(&DataZoneClient::UpdateEnvironmentBlueprint, request);
  }
 
  template <typename UpdateEnvironmentBlueprintRequestT = Model::UpdateEnvironmentBlueprintRequest>
  void UpdateEnvironmentBlueprintAsync(const UpdateEnvironmentBlueprintRequestT& request,
                                       const UpdateEnvironmentBlueprintResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::UpdateEnvironmentBlueprint, 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::UpdateNotebookOutcome UpdateNotebook(const Model::UpdateNotebookRequest& request) const;
 
  template <typename UpdateNotebookRequestT = Model::UpdateNotebookRequest>
  Model::UpdateNotebookOutcomeCallable UpdateNotebookCallable(const UpdateNotebookRequestT& request) const {
    return SubmitCallable(&DataZoneClient::UpdateNotebook, request);
  }
 
  template <typename UpdateNotebookRequestT = Model::UpdateNotebookRequest>
  void UpdateNotebookAsync(const UpdateNotebookRequestT& request, const UpdateNotebookResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::UpdateNotebook, 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::UpdateRootDomainUnitOwnerOutcome UpdateRootDomainUnitOwner(const Model::UpdateRootDomainUnitOwnerRequest& request) const;
 
  template <typename UpdateRootDomainUnitOwnerRequestT = Model::UpdateRootDomainUnitOwnerRequest>
  Model::UpdateRootDomainUnitOwnerOutcomeCallable UpdateRootDomainUnitOwnerCallable(
      const UpdateRootDomainUnitOwnerRequestT& request) const {
    return SubmitCallable(&DataZoneClient::UpdateRootDomainUnitOwner, request);
  }
 
  template <typename UpdateRootDomainUnitOwnerRequestT = Model::UpdateRootDomainUnitOwnerRequest>
  void UpdateRootDomainUnitOwnerAsync(const UpdateRootDomainUnitOwnerRequestT& request,
                                      const UpdateRootDomainUnitOwnerResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataZoneClient::UpdateRootDomainUnitOwner, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<DataZoneEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DataZoneClient>;
  void init(const DataZoneClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, DataZoneError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  DataZoneClientConfiguration m_clientConfiguration;
  std::shared_ptr<DataZoneEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DataZone
}  // namespace Aws