OmicsClient.h

 
#pragma once
#include <aws/omics/Omics_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/omics/OmicsServiceClientModel.h>
 
namespace Aws
{
namespace Omics
{
  class AWS_OMICS_API OmicsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<OmicsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef OmicsClientConfiguration ClientConfigurationType;
      typedef OmicsEndpointProvider EndpointProviderType;
 
        OmicsClient(const Aws::Omics::OmicsClientConfiguration& clientConfiguration = Aws::Omics::OmicsClientConfiguration(),
                    std::shared_ptr<OmicsEndpointProviderBase> endpointProvider = nullptr);
 
        OmicsClient(const Aws::Auth::AWSCredentials& credentials,
                    std::shared_ptr<OmicsEndpointProviderBase> endpointProvider = nullptr,
                    const Aws::Omics::OmicsClientConfiguration& clientConfiguration = Aws::Omics::OmicsClientConfiguration());
 
        OmicsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    std::shared_ptr<OmicsEndpointProviderBase> endpointProvider = nullptr,
                    const Aws::Omics::OmicsClientConfiguration& clientConfiguration = Aws::Omics::OmicsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        OmicsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        OmicsClient(const Aws::Auth::AWSCredentials& credentials,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
        OmicsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~OmicsClient();
 
        virtual Model::AbortMultipartReadSetUploadOutcome AbortMultipartReadSetUpload(const Model::AbortMultipartReadSetUploadRequest& request) const;
 
        template<typename AbortMultipartReadSetUploadRequestT = Model::AbortMultipartReadSetUploadRequest>
        Model::AbortMultipartReadSetUploadOutcomeCallable AbortMultipartReadSetUploadCallable(const AbortMultipartReadSetUploadRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::AbortMultipartReadSetUpload, request);
        }
 
        template<typename AbortMultipartReadSetUploadRequestT = Model::AbortMultipartReadSetUploadRequest>
        void AbortMultipartReadSetUploadAsync(const AbortMultipartReadSetUploadRequestT& request, const AbortMultipartReadSetUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::AbortMultipartReadSetUpload, request, handler, context);
        }
 
        virtual Model::AcceptShareOutcome AcceptShare(const Model::AcceptShareRequest& request) const;
 
        template<typename AcceptShareRequestT = Model::AcceptShareRequest>
        Model::AcceptShareOutcomeCallable AcceptShareCallable(const AcceptShareRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::AcceptShare, request);
        }
 
        template<typename AcceptShareRequestT = Model::AcceptShareRequest>
        void AcceptShareAsync(const AcceptShareRequestT& request, const AcceptShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::AcceptShare, request, handler, context);
        }
 
        virtual Model::BatchDeleteReadSetOutcome BatchDeleteReadSet(const Model::BatchDeleteReadSetRequest& request) const;
 
        template<typename BatchDeleteReadSetRequestT = Model::BatchDeleteReadSetRequest>
        Model::BatchDeleteReadSetOutcomeCallable BatchDeleteReadSetCallable(const BatchDeleteReadSetRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::BatchDeleteReadSet, request);
        }
 
        template<typename BatchDeleteReadSetRequestT = Model::BatchDeleteReadSetRequest>
        void BatchDeleteReadSetAsync(const BatchDeleteReadSetRequestT& request, const BatchDeleteReadSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::BatchDeleteReadSet, request, handler, context);
        }
 
        virtual Model::CancelAnnotationImportJobOutcome CancelAnnotationImportJob(const Model::CancelAnnotationImportJobRequest& request) const;
 
        template<typename CancelAnnotationImportJobRequestT = Model::CancelAnnotationImportJobRequest>
        Model::CancelAnnotationImportJobOutcomeCallable CancelAnnotationImportJobCallable(const CancelAnnotationImportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CancelAnnotationImportJob, request);
        }
 
        template<typename CancelAnnotationImportJobRequestT = Model::CancelAnnotationImportJobRequest>
        void CancelAnnotationImportJobAsync(const CancelAnnotationImportJobRequestT& request, const CancelAnnotationImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CancelAnnotationImportJob, request, handler, context);
        }
 
        virtual Model::CancelRunOutcome CancelRun(const Model::CancelRunRequest& request) const;
 
        template<typename CancelRunRequestT = Model::CancelRunRequest>
        Model::CancelRunOutcomeCallable CancelRunCallable(const CancelRunRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CancelRun, request);
        }
 
        template<typename CancelRunRequestT = Model::CancelRunRequest>
        void CancelRunAsync(const CancelRunRequestT& request, const CancelRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CancelRun, request, handler, context);
        }
 
        virtual Model::CancelVariantImportJobOutcome CancelVariantImportJob(const Model::CancelVariantImportJobRequest& request) const;
 
        template<typename CancelVariantImportJobRequestT = Model::CancelVariantImportJobRequest>
        Model::CancelVariantImportJobOutcomeCallable CancelVariantImportJobCallable(const CancelVariantImportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CancelVariantImportJob, request);
        }
 
        template<typename CancelVariantImportJobRequestT = Model::CancelVariantImportJobRequest>
        void CancelVariantImportJobAsync(const CancelVariantImportJobRequestT& request, const CancelVariantImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CancelVariantImportJob, request, handler, context);
        }
 
        virtual Model::CompleteMultipartReadSetUploadOutcome CompleteMultipartReadSetUpload(const Model::CompleteMultipartReadSetUploadRequest& request) const;
 
        template<typename CompleteMultipartReadSetUploadRequestT = Model::CompleteMultipartReadSetUploadRequest>
        Model::CompleteMultipartReadSetUploadOutcomeCallable CompleteMultipartReadSetUploadCallable(const CompleteMultipartReadSetUploadRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CompleteMultipartReadSetUpload, request);
        }
 
        template<typename CompleteMultipartReadSetUploadRequestT = Model::CompleteMultipartReadSetUploadRequest>
        void CompleteMultipartReadSetUploadAsync(const CompleteMultipartReadSetUploadRequestT& request, const CompleteMultipartReadSetUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CompleteMultipartReadSetUpload, request, handler, context);
        }
 
        virtual Model::CreateAnnotationStoreOutcome CreateAnnotationStore(const Model::CreateAnnotationStoreRequest& request) const;
 
        template<typename CreateAnnotationStoreRequestT = Model::CreateAnnotationStoreRequest>
        Model::CreateAnnotationStoreOutcomeCallable CreateAnnotationStoreCallable(const CreateAnnotationStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CreateAnnotationStore, request);
        }
 
        template<typename CreateAnnotationStoreRequestT = Model::CreateAnnotationStoreRequest>
        void CreateAnnotationStoreAsync(const CreateAnnotationStoreRequestT& request, const CreateAnnotationStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CreateAnnotationStore, request, handler, context);
        }
 
        virtual Model::CreateAnnotationStoreVersionOutcome CreateAnnotationStoreVersion(const Model::CreateAnnotationStoreVersionRequest& request) const;
 
        template<typename CreateAnnotationStoreVersionRequestT = Model::CreateAnnotationStoreVersionRequest>
        Model::CreateAnnotationStoreVersionOutcomeCallable CreateAnnotationStoreVersionCallable(const CreateAnnotationStoreVersionRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CreateAnnotationStoreVersion, request);
        }
 
        template<typename CreateAnnotationStoreVersionRequestT = Model::CreateAnnotationStoreVersionRequest>
        void CreateAnnotationStoreVersionAsync(const CreateAnnotationStoreVersionRequestT& request, const CreateAnnotationStoreVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CreateAnnotationStoreVersion, request, handler, context);
        }
 
        virtual Model::CreateMultipartReadSetUploadOutcome CreateMultipartReadSetUpload(const Model::CreateMultipartReadSetUploadRequest& request) const;
 
        template<typename CreateMultipartReadSetUploadRequestT = Model::CreateMultipartReadSetUploadRequest>
        Model::CreateMultipartReadSetUploadOutcomeCallable CreateMultipartReadSetUploadCallable(const CreateMultipartReadSetUploadRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CreateMultipartReadSetUpload, request);
        }
 
        template<typename CreateMultipartReadSetUploadRequestT = Model::CreateMultipartReadSetUploadRequest>
        void CreateMultipartReadSetUploadAsync(const CreateMultipartReadSetUploadRequestT& request, const CreateMultipartReadSetUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CreateMultipartReadSetUpload, request, handler, context);
        }
 
        virtual Model::CreateReferenceStoreOutcome CreateReferenceStore(const Model::CreateReferenceStoreRequest& request) const;
 
        template<typename CreateReferenceStoreRequestT = Model::CreateReferenceStoreRequest>
        Model::CreateReferenceStoreOutcomeCallable CreateReferenceStoreCallable(const CreateReferenceStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CreateReferenceStore, request);
        }
 
        template<typename CreateReferenceStoreRequestT = Model::CreateReferenceStoreRequest>
        void CreateReferenceStoreAsync(const CreateReferenceStoreRequestT& request, const CreateReferenceStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CreateReferenceStore, request, handler, context);
        }
 
        virtual Model::CreateRunCacheOutcome CreateRunCache(const Model::CreateRunCacheRequest& request) const;
 
        template<typename CreateRunCacheRequestT = Model::CreateRunCacheRequest>
        Model::CreateRunCacheOutcomeCallable CreateRunCacheCallable(const CreateRunCacheRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CreateRunCache, request);
        }
 
        template<typename CreateRunCacheRequestT = Model::CreateRunCacheRequest>
        void CreateRunCacheAsync(const CreateRunCacheRequestT& request, const CreateRunCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CreateRunCache, request, handler, context);
        }
 
        virtual Model::CreateRunGroupOutcome CreateRunGroup(const Model::CreateRunGroupRequest& request) const;
 
        template<typename CreateRunGroupRequestT = Model::CreateRunGroupRequest>
        Model::CreateRunGroupOutcomeCallable CreateRunGroupCallable(const CreateRunGroupRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CreateRunGroup, request);
        }
 
        template<typename CreateRunGroupRequestT = Model::CreateRunGroupRequest>
        void CreateRunGroupAsync(const CreateRunGroupRequestT& request, const CreateRunGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CreateRunGroup, request, handler, context);
        }
 
        virtual Model::CreateSequenceStoreOutcome CreateSequenceStore(const Model::CreateSequenceStoreRequest& request) const;
 
        template<typename CreateSequenceStoreRequestT = Model::CreateSequenceStoreRequest>
        Model::CreateSequenceStoreOutcomeCallable CreateSequenceStoreCallable(const CreateSequenceStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CreateSequenceStore, request);
        }
 
        template<typename CreateSequenceStoreRequestT = Model::CreateSequenceStoreRequest>
        void CreateSequenceStoreAsync(const CreateSequenceStoreRequestT& request, const CreateSequenceStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CreateSequenceStore, request, handler, context);
        }
 
        virtual Model::CreateShareOutcome CreateShare(const Model::CreateShareRequest& request) const;
 
        template<typename CreateShareRequestT = Model::CreateShareRequest>
        Model::CreateShareOutcomeCallable CreateShareCallable(const CreateShareRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CreateShare, request);
        }
 
        template<typename CreateShareRequestT = Model::CreateShareRequest>
        void CreateShareAsync(const CreateShareRequestT& request, const CreateShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CreateShare, request, handler, context);
        }
 
        virtual Model::CreateVariantStoreOutcome CreateVariantStore(const Model::CreateVariantStoreRequest& request) const;
 
        template<typename CreateVariantStoreRequestT = Model::CreateVariantStoreRequest>
        Model::CreateVariantStoreOutcomeCallable CreateVariantStoreCallable(const CreateVariantStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CreateVariantStore, request);
        }
 
        template<typename CreateVariantStoreRequestT = Model::CreateVariantStoreRequest>
        void CreateVariantStoreAsync(const CreateVariantStoreRequestT& request, const CreateVariantStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CreateVariantStore, request, handler, context);
        }
 
        virtual Model::CreateWorkflowOutcome CreateWorkflow(const Model::CreateWorkflowRequest& request) const;
 
        template<typename CreateWorkflowRequestT = Model::CreateWorkflowRequest>
        Model::CreateWorkflowOutcomeCallable CreateWorkflowCallable(const CreateWorkflowRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CreateWorkflow, request);
        }
 
        template<typename CreateWorkflowRequestT = Model::CreateWorkflowRequest>
        void CreateWorkflowAsync(const CreateWorkflowRequestT& request, const CreateWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CreateWorkflow, request, handler, context);
        }
 
        virtual Model::CreateWorkflowVersionOutcome CreateWorkflowVersion(const Model::CreateWorkflowVersionRequest& request) const;
 
        template<typename CreateWorkflowVersionRequestT = Model::CreateWorkflowVersionRequest>
        Model::CreateWorkflowVersionOutcomeCallable CreateWorkflowVersionCallable(const CreateWorkflowVersionRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::CreateWorkflowVersion, request);
        }
 
        template<typename CreateWorkflowVersionRequestT = Model::CreateWorkflowVersionRequest>
        void CreateWorkflowVersionAsync(const CreateWorkflowVersionRequestT& request, const CreateWorkflowVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::CreateWorkflowVersion, request, handler, context);
        }
 
        virtual Model::DeleteAnnotationStoreOutcome DeleteAnnotationStore(const Model::DeleteAnnotationStoreRequest& request) const;
 
        template<typename DeleteAnnotationStoreRequestT = Model::DeleteAnnotationStoreRequest>
        Model::DeleteAnnotationStoreOutcomeCallable DeleteAnnotationStoreCallable(const DeleteAnnotationStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteAnnotationStore, request);
        }
 
        template<typename DeleteAnnotationStoreRequestT = Model::DeleteAnnotationStoreRequest>
        void DeleteAnnotationStoreAsync(const DeleteAnnotationStoreRequestT& request, const DeleteAnnotationStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteAnnotationStore, request, handler, context);
        }
 
        virtual Model::DeleteAnnotationStoreVersionsOutcome DeleteAnnotationStoreVersions(const Model::DeleteAnnotationStoreVersionsRequest& request) const;
 
        template<typename DeleteAnnotationStoreVersionsRequestT = Model::DeleteAnnotationStoreVersionsRequest>
        Model::DeleteAnnotationStoreVersionsOutcomeCallable DeleteAnnotationStoreVersionsCallable(const DeleteAnnotationStoreVersionsRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteAnnotationStoreVersions, request);
        }
 
        template<typename DeleteAnnotationStoreVersionsRequestT = Model::DeleteAnnotationStoreVersionsRequest>
        void DeleteAnnotationStoreVersionsAsync(const DeleteAnnotationStoreVersionsRequestT& request, const DeleteAnnotationStoreVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteAnnotationStoreVersions, request, handler, context);
        }
 
        virtual Model::DeleteReferenceOutcome DeleteReference(const Model::DeleteReferenceRequest& request) const;
 
        template<typename DeleteReferenceRequestT = Model::DeleteReferenceRequest>
        Model::DeleteReferenceOutcomeCallable DeleteReferenceCallable(const DeleteReferenceRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteReference, request);
        }
 
        template<typename DeleteReferenceRequestT = Model::DeleteReferenceRequest>
        void DeleteReferenceAsync(const DeleteReferenceRequestT& request, const DeleteReferenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteReference, request, handler, context);
        }
 
        virtual Model::DeleteReferenceStoreOutcome DeleteReferenceStore(const Model::DeleteReferenceStoreRequest& request) const;
 
        template<typename DeleteReferenceStoreRequestT = Model::DeleteReferenceStoreRequest>
        Model::DeleteReferenceStoreOutcomeCallable DeleteReferenceStoreCallable(const DeleteReferenceStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteReferenceStore, request);
        }
 
        template<typename DeleteReferenceStoreRequestT = Model::DeleteReferenceStoreRequest>
        void DeleteReferenceStoreAsync(const DeleteReferenceStoreRequestT& request, const DeleteReferenceStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteReferenceStore, request, handler, context);
        }
 
        virtual Model::DeleteRunOutcome DeleteRun(const Model::DeleteRunRequest& request) const;
 
        template<typename DeleteRunRequestT = Model::DeleteRunRequest>
        Model::DeleteRunOutcomeCallable DeleteRunCallable(const DeleteRunRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteRun, request);
        }
 
        template<typename DeleteRunRequestT = Model::DeleteRunRequest>
        void DeleteRunAsync(const DeleteRunRequestT& request, const DeleteRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteRun, request, handler, context);
        }
 
        virtual Model::DeleteRunCacheOutcome DeleteRunCache(const Model::DeleteRunCacheRequest& request) const;
 
        template<typename DeleteRunCacheRequestT = Model::DeleteRunCacheRequest>
        Model::DeleteRunCacheOutcomeCallable DeleteRunCacheCallable(const DeleteRunCacheRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteRunCache, request);
        }
 
        template<typename DeleteRunCacheRequestT = Model::DeleteRunCacheRequest>
        void DeleteRunCacheAsync(const DeleteRunCacheRequestT& request, const DeleteRunCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteRunCache, request, handler, context);
        }
 
        virtual Model::DeleteRunGroupOutcome DeleteRunGroup(const Model::DeleteRunGroupRequest& request) const;
 
        template<typename DeleteRunGroupRequestT = Model::DeleteRunGroupRequest>
        Model::DeleteRunGroupOutcomeCallable DeleteRunGroupCallable(const DeleteRunGroupRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteRunGroup, request);
        }
 
        template<typename DeleteRunGroupRequestT = Model::DeleteRunGroupRequest>
        void DeleteRunGroupAsync(const DeleteRunGroupRequestT& request, const DeleteRunGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteRunGroup, request, handler, context);
        }
 
        virtual Model::DeleteS3AccessPolicyOutcome DeleteS3AccessPolicy(const Model::DeleteS3AccessPolicyRequest& request) const;
 
        template<typename DeleteS3AccessPolicyRequestT = Model::DeleteS3AccessPolicyRequest>
        Model::DeleteS3AccessPolicyOutcomeCallable DeleteS3AccessPolicyCallable(const DeleteS3AccessPolicyRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteS3AccessPolicy, request);
        }
 
        template<typename DeleteS3AccessPolicyRequestT = Model::DeleteS3AccessPolicyRequest>
        void DeleteS3AccessPolicyAsync(const DeleteS3AccessPolicyRequestT& request, const DeleteS3AccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteS3AccessPolicy, request, handler, context);
        }
 
        virtual Model::DeleteSequenceStoreOutcome DeleteSequenceStore(const Model::DeleteSequenceStoreRequest& request) const;
 
        template<typename DeleteSequenceStoreRequestT = Model::DeleteSequenceStoreRequest>
        Model::DeleteSequenceStoreOutcomeCallable DeleteSequenceStoreCallable(const DeleteSequenceStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteSequenceStore, request);
        }
 
        template<typename DeleteSequenceStoreRequestT = Model::DeleteSequenceStoreRequest>
        void DeleteSequenceStoreAsync(const DeleteSequenceStoreRequestT& request, const DeleteSequenceStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteSequenceStore, request, handler, context);
        }
 
        virtual Model::DeleteShareOutcome DeleteShare(const Model::DeleteShareRequest& request) const;
 
        template<typename DeleteShareRequestT = Model::DeleteShareRequest>
        Model::DeleteShareOutcomeCallable DeleteShareCallable(const DeleteShareRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteShare, request);
        }
 
        template<typename DeleteShareRequestT = Model::DeleteShareRequest>
        void DeleteShareAsync(const DeleteShareRequestT& request, const DeleteShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteShare, request, handler, context);
        }
 
        virtual Model::DeleteVariantStoreOutcome DeleteVariantStore(const Model::DeleteVariantStoreRequest& request) const;
 
        template<typename DeleteVariantStoreRequestT = Model::DeleteVariantStoreRequest>
        Model::DeleteVariantStoreOutcomeCallable DeleteVariantStoreCallable(const DeleteVariantStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteVariantStore, request);
        }
 
        template<typename DeleteVariantStoreRequestT = Model::DeleteVariantStoreRequest>
        void DeleteVariantStoreAsync(const DeleteVariantStoreRequestT& request, const DeleteVariantStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteVariantStore, request, handler, context);
        }
 
        virtual Model::DeleteWorkflowOutcome DeleteWorkflow(const Model::DeleteWorkflowRequest& request) const;
 
        template<typename DeleteWorkflowRequestT = Model::DeleteWorkflowRequest>
        Model::DeleteWorkflowOutcomeCallable DeleteWorkflowCallable(const DeleteWorkflowRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteWorkflow, request);
        }
 
        template<typename DeleteWorkflowRequestT = Model::DeleteWorkflowRequest>
        void DeleteWorkflowAsync(const DeleteWorkflowRequestT& request, const DeleteWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteWorkflow, request, handler, context);
        }
 
        virtual Model::DeleteWorkflowVersionOutcome DeleteWorkflowVersion(const Model::DeleteWorkflowVersionRequest& request) const;
 
        template<typename DeleteWorkflowVersionRequestT = Model::DeleteWorkflowVersionRequest>
        Model::DeleteWorkflowVersionOutcomeCallable DeleteWorkflowVersionCallable(const DeleteWorkflowVersionRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::DeleteWorkflowVersion, request);
        }
 
        template<typename DeleteWorkflowVersionRequestT = Model::DeleteWorkflowVersionRequest>
        void DeleteWorkflowVersionAsync(const DeleteWorkflowVersionRequestT& request, const DeleteWorkflowVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::DeleteWorkflowVersion, request, handler, context);
        }
 
        virtual Model::GetAnnotationImportJobOutcome GetAnnotationImportJob(const Model::GetAnnotationImportJobRequest& request) const;
 
        template<typename GetAnnotationImportJobRequestT = Model::GetAnnotationImportJobRequest>
        Model::GetAnnotationImportJobOutcomeCallable GetAnnotationImportJobCallable(const GetAnnotationImportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetAnnotationImportJob, request);
        }
 
        template<typename GetAnnotationImportJobRequestT = Model::GetAnnotationImportJobRequest>
        void GetAnnotationImportJobAsync(const GetAnnotationImportJobRequestT& request, const GetAnnotationImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetAnnotationImportJob, request, handler, context);
        }
 
        virtual Model::GetAnnotationStoreOutcome GetAnnotationStore(const Model::GetAnnotationStoreRequest& request) const;
 
        template<typename GetAnnotationStoreRequestT = Model::GetAnnotationStoreRequest>
        Model::GetAnnotationStoreOutcomeCallable GetAnnotationStoreCallable(const GetAnnotationStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetAnnotationStore, request);
        }
 
        template<typename GetAnnotationStoreRequestT = Model::GetAnnotationStoreRequest>
        void GetAnnotationStoreAsync(const GetAnnotationStoreRequestT& request, const GetAnnotationStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetAnnotationStore, request, handler, context);
        }
 
        virtual Model::GetAnnotationStoreVersionOutcome GetAnnotationStoreVersion(const Model::GetAnnotationStoreVersionRequest& request) const;
 
        template<typename GetAnnotationStoreVersionRequestT = Model::GetAnnotationStoreVersionRequest>
        Model::GetAnnotationStoreVersionOutcomeCallable GetAnnotationStoreVersionCallable(const GetAnnotationStoreVersionRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetAnnotationStoreVersion, request);
        }
 
        template<typename GetAnnotationStoreVersionRequestT = Model::GetAnnotationStoreVersionRequest>
        void GetAnnotationStoreVersionAsync(const GetAnnotationStoreVersionRequestT& request, const GetAnnotationStoreVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetAnnotationStoreVersion, request, handler, context);
        }
 
        virtual Model::GetReadSetOutcome GetReadSet(const Model::GetReadSetRequest& request) const;
 
        template<typename GetReadSetRequestT = Model::GetReadSetRequest>
        Model::GetReadSetOutcomeCallable GetReadSetCallable(const GetReadSetRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetReadSet, request);
        }
 
        template<typename GetReadSetRequestT = Model::GetReadSetRequest>
        void GetReadSetAsync(const GetReadSetRequestT& request, const GetReadSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetReadSet, request, handler, context);
        }
 
        virtual Model::GetReadSetActivationJobOutcome GetReadSetActivationJob(const Model::GetReadSetActivationJobRequest& request) const;
 
        template<typename GetReadSetActivationJobRequestT = Model::GetReadSetActivationJobRequest>
        Model::GetReadSetActivationJobOutcomeCallable GetReadSetActivationJobCallable(const GetReadSetActivationJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetReadSetActivationJob, request);
        }
 
        template<typename GetReadSetActivationJobRequestT = Model::GetReadSetActivationJobRequest>
        void GetReadSetActivationJobAsync(const GetReadSetActivationJobRequestT& request, const GetReadSetActivationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetReadSetActivationJob, request, handler, context);
        }
 
        virtual Model::GetReadSetExportJobOutcome GetReadSetExportJob(const Model::GetReadSetExportJobRequest& request) const;
 
        template<typename GetReadSetExportJobRequestT = Model::GetReadSetExportJobRequest>
        Model::GetReadSetExportJobOutcomeCallable GetReadSetExportJobCallable(const GetReadSetExportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetReadSetExportJob, request);
        }
 
        template<typename GetReadSetExportJobRequestT = Model::GetReadSetExportJobRequest>
        void GetReadSetExportJobAsync(const GetReadSetExportJobRequestT& request, const GetReadSetExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetReadSetExportJob, request, handler, context);
        }
 
        virtual Model::GetReadSetImportJobOutcome GetReadSetImportJob(const Model::GetReadSetImportJobRequest& request) const;
 
        template<typename GetReadSetImportJobRequestT = Model::GetReadSetImportJobRequest>
        Model::GetReadSetImportJobOutcomeCallable GetReadSetImportJobCallable(const GetReadSetImportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetReadSetImportJob, request);
        }
 
        template<typename GetReadSetImportJobRequestT = Model::GetReadSetImportJobRequest>
        void GetReadSetImportJobAsync(const GetReadSetImportJobRequestT& request, const GetReadSetImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetReadSetImportJob, request, handler, context);
        }
 
        virtual Model::GetReadSetMetadataOutcome GetReadSetMetadata(const Model::GetReadSetMetadataRequest& request) const;
 
        template<typename GetReadSetMetadataRequestT = Model::GetReadSetMetadataRequest>
        Model::GetReadSetMetadataOutcomeCallable GetReadSetMetadataCallable(const GetReadSetMetadataRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetReadSetMetadata, request);
        }
 
        template<typename GetReadSetMetadataRequestT = Model::GetReadSetMetadataRequest>
        void GetReadSetMetadataAsync(const GetReadSetMetadataRequestT& request, const GetReadSetMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetReadSetMetadata, request, handler, context);
        }
 
        virtual Model::GetReferenceOutcome GetReference(const Model::GetReferenceRequest& request) const;
 
        template<typename GetReferenceRequestT = Model::GetReferenceRequest>
        Model::GetReferenceOutcomeCallable GetReferenceCallable(const GetReferenceRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetReference, request);
        }
 
        template<typename GetReferenceRequestT = Model::GetReferenceRequest>
        void GetReferenceAsync(const GetReferenceRequestT& request, const GetReferenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetReference, request, handler, context);
        }
 
        virtual Model::GetReferenceImportJobOutcome GetReferenceImportJob(const Model::GetReferenceImportJobRequest& request) const;
 
        template<typename GetReferenceImportJobRequestT = Model::GetReferenceImportJobRequest>
        Model::GetReferenceImportJobOutcomeCallable GetReferenceImportJobCallable(const GetReferenceImportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetReferenceImportJob, request);
        }
 
        template<typename GetReferenceImportJobRequestT = Model::GetReferenceImportJobRequest>
        void GetReferenceImportJobAsync(const GetReferenceImportJobRequestT& request, const GetReferenceImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetReferenceImportJob, request, handler, context);
        }
 
        virtual Model::GetReferenceMetadataOutcome GetReferenceMetadata(const Model::GetReferenceMetadataRequest& request) const;
 
        template<typename GetReferenceMetadataRequestT = Model::GetReferenceMetadataRequest>
        Model::GetReferenceMetadataOutcomeCallable GetReferenceMetadataCallable(const GetReferenceMetadataRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetReferenceMetadata, request);
        }
 
        template<typename GetReferenceMetadataRequestT = Model::GetReferenceMetadataRequest>
        void GetReferenceMetadataAsync(const GetReferenceMetadataRequestT& request, const GetReferenceMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetReferenceMetadata, request, handler, context);
        }
 
        virtual Model::GetReferenceStoreOutcome GetReferenceStore(const Model::GetReferenceStoreRequest& request) const;
 
        template<typename GetReferenceStoreRequestT = Model::GetReferenceStoreRequest>
        Model::GetReferenceStoreOutcomeCallable GetReferenceStoreCallable(const GetReferenceStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetReferenceStore, request);
        }
 
        template<typename GetReferenceStoreRequestT = Model::GetReferenceStoreRequest>
        void GetReferenceStoreAsync(const GetReferenceStoreRequestT& request, const GetReferenceStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetReferenceStore, request, handler, context);
        }
 
        virtual Model::GetRunOutcome GetRun(const Model::GetRunRequest& request) const;
 
        template<typename GetRunRequestT = Model::GetRunRequest>
        Model::GetRunOutcomeCallable GetRunCallable(const GetRunRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetRun, request);
        }
 
        template<typename GetRunRequestT = Model::GetRunRequest>
        void GetRunAsync(const GetRunRequestT& request, const GetRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetRun, request, handler, context);
        }
 
        virtual Model::GetRunCacheOutcome GetRunCache(const Model::GetRunCacheRequest& request) const;
 
        template<typename GetRunCacheRequestT = Model::GetRunCacheRequest>
        Model::GetRunCacheOutcomeCallable GetRunCacheCallable(const GetRunCacheRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetRunCache, request);
        }
 
        template<typename GetRunCacheRequestT = Model::GetRunCacheRequest>
        void GetRunCacheAsync(const GetRunCacheRequestT& request, const GetRunCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetRunCache, request, handler, context);
        }
 
        virtual Model::GetRunGroupOutcome GetRunGroup(const Model::GetRunGroupRequest& request) const;
 
        template<typename GetRunGroupRequestT = Model::GetRunGroupRequest>
        Model::GetRunGroupOutcomeCallable GetRunGroupCallable(const GetRunGroupRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetRunGroup, request);
        }
 
        template<typename GetRunGroupRequestT = Model::GetRunGroupRequest>
        void GetRunGroupAsync(const GetRunGroupRequestT& request, const GetRunGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetRunGroup, request, handler, context);
        }
 
        virtual Model::GetRunTaskOutcome GetRunTask(const Model::GetRunTaskRequest& request) const;
 
        template<typename GetRunTaskRequestT = Model::GetRunTaskRequest>
        Model::GetRunTaskOutcomeCallable GetRunTaskCallable(const GetRunTaskRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetRunTask, request);
        }
 
        template<typename GetRunTaskRequestT = Model::GetRunTaskRequest>
        void GetRunTaskAsync(const GetRunTaskRequestT& request, const GetRunTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetRunTask, request, handler, context);
        }
 
        virtual Model::GetS3AccessPolicyOutcome GetS3AccessPolicy(const Model::GetS3AccessPolicyRequest& request) const;
 
        template<typename GetS3AccessPolicyRequestT = Model::GetS3AccessPolicyRequest>
        Model::GetS3AccessPolicyOutcomeCallable GetS3AccessPolicyCallable(const GetS3AccessPolicyRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetS3AccessPolicy, request);
        }
 
        template<typename GetS3AccessPolicyRequestT = Model::GetS3AccessPolicyRequest>
        void GetS3AccessPolicyAsync(const GetS3AccessPolicyRequestT& request, const GetS3AccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetS3AccessPolicy, request, handler, context);
        }
 
        virtual Model::GetSequenceStoreOutcome GetSequenceStore(const Model::GetSequenceStoreRequest& request) const;
 
        template<typename GetSequenceStoreRequestT = Model::GetSequenceStoreRequest>
        Model::GetSequenceStoreOutcomeCallable GetSequenceStoreCallable(const GetSequenceStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetSequenceStore, request);
        }
 
        template<typename GetSequenceStoreRequestT = Model::GetSequenceStoreRequest>
        void GetSequenceStoreAsync(const GetSequenceStoreRequestT& request, const GetSequenceStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetSequenceStore, request, handler, context);
        }
 
        virtual Model::GetShareOutcome GetShare(const Model::GetShareRequest& request) const;
 
        template<typename GetShareRequestT = Model::GetShareRequest>
        Model::GetShareOutcomeCallable GetShareCallable(const GetShareRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetShare, request);
        }
 
        template<typename GetShareRequestT = Model::GetShareRequest>
        void GetShareAsync(const GetShareRequestT& request, const GetShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetShare, request, handler, context);
        }
 
        virtual Model::GetVariantImportJobOutcome GetVariantImportJob(const Model::GetVariantImportJobRequest& request) const;
 
        template<typename GetVariantImportJobRequestT = Model::GetVariantImportJobRequest>
        Model::GetVariantImportJobOutcomeCallable GetVariantImportJobCallable(const GetVariantImportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetVariantImportJob, request);
        }
 
        template<typename GetVariantImportJobRequestT = Model::GetVariantImportJobRequest>
        void GetVariantImportJobAsync(const GetVariantImportJobRequestT& request, const GetVariantImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetVariantImportJob, request, handler, context);
        }
 
        virtual Model::GetVariantStoreOutcome GetVariantStore(const Model::GetVariantStoreRequest& request) const;
 
        template<typename GetVariantStoreRequestT = Model::GetVariantStoreRequest>
        Model::GetVariantStoreOutcomeCallable GetVariantStoreCallable(const GetVariantStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetVariantStore, request);
        }
 
        template<typename GetVariantStoreRequestT = Model::GetVariantStoreRequest>
        void GetVariantStoreAsync(const GetVariantStoreRequestT& request, const GetVariantStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetVariantStore, request, handler, context);
        }
 
        virtual Model::GetWorkflowOutcome GetWorkflow(const Model::GetWorkflowRequest& request) const;
 
        template<typename GetWorkflowRequestT = Model::GetWorkflowRequest>
        Model::GetWorkflowOutcomeCallable GetWorkflowCallable(const GetWorkflowRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetWorkflow, request);
        }
 
        template<typename GetWorkflowRequestT = Model::GetWorkflowRequest>
        void GetWorkflowAsync(const GetWorkflowRequestT& request, const GetWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetWorkflow, request, handler, context);
        }
 
        virtual Model::GetWorkflowVersionOutcome GetWorkflowVersion(const Model::GetWorkflowVersionRequest& request) const;
 
        template<typename GetWorkflowVersionRequestT = Model::GetWorkflowVersionRequest>
        Model::GetWorkflowVersionOutcomeCallable GetWorkflowVersionCallable(const GetWorkflowVersionRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::GetWorkflowVersion, request);
        }
 
        template<typename GetWorkflowVersionRequestT = Model::GetWorkflowVersionRequest>
        void GetWorkflowVersionAsync(const GetWorkflowVersionRequestT& request, const GetWorkflowVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::GetWorkflowVersion, request, handler, context);
        }
 
        virtual Model::ListAnnotationImportJobsOutcome ListAnnotationImportJobs(const Model::ListAnnotationImportJobsRequest& request = {}) const;
 
        template<typename ListAnnotationImportJobsRequestT = Model::ListAnnotationImportJobsRequest>
        Model::ListAnnotationImportJobsOutcomeCallable ListAnnotationImportJobsCallable(const ListAnnotationImportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&OmicsClient::ListAnnotationImportJobs, request);
        }
 
        template<typename ListAnnotationImportJobsRequestT = Model::ListAnnotationImportJobsRequest>
        void ListAnnotationImportJobsAsync(const ListAnnotationImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAnnotationImportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&OmicsClient::ListAnnotationImportJobs, request, handler, context);
        }
 
        virtual Model::ListAnnotationStoreVersionsOutcome ListAnnotationStoreVersions(const Model::ListAnnotationStoreVersionsRequest& request) const;
 
        template<typename ListAnnotationStoreVersionsRequestT = Model::ListAnnotationStoreVersionsRequest>
        Model::ListAnnotationStoreVersionsOutcomeCallable ListAnnotationStoreVersionsCallable(const ListAnnotationStoreVersionsRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListAnnotationStoreVersions, request);
        }
 
        template<typename ListAnnotationStoreVersionsRequestT = Model::ListAnnotationStoreVersionsRequest>
        void ListAnnotationStoreVersionsAsync(const ListAnnotationStoreVersionsRequestT& request, const ListAnnotationStoreVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListAnnotationStoreVersions, request, handler, context);
        }
 
        virtual Model::ListAnnotationStoresOutcome ListAnnotationStores(const Model::ListAnnotationStoresRequest& request = {}) const;
 
        template<typename ListAnnotationStoresRequestT = Model::ListAnnotationStoresRequest>
        Model::ListAnnotationStoresOutcomeCallable ListAnnotationStoresCallable(const ListAnnotationStoresRequestT& request = {}) const
        {
            return SubmitCallable(&OmicsClient::ListAnnotationStores, request);
        }
 
        template<typename ListAnnotationStoresRequestT = Model::ListAnnotationStoresRequest>
        void ListAnnotationStoresAsync(const ListAnnotationStoresResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAnnotationStoresRequestT& request = {}) const
        {
            return SubmitAsync(&OmicsClient::ListAnnotationStores, request, handler, context);
        }
 
        virtual Model::ListMultipartReadSetUploadsOutcome ListMultipartReadSetUploads(const Model::ListMultipartReadSetUploadsRequest& request) const;
 
        template<typename ListMultipartReadSetUploadsRequestT = Model::ListMultipartReadSetUploadsRequest>
        Model::ListMultipartReadSetUploadsOutcomeCallable ListMultipartReadSetUploadsCallable(const ListMultipartReadSetUploadsRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListMultipartReadSetUploads, request);
        }
 
        template<typename ListMultipartReadSetUploadsRequestT = Model::ListMultipartReadSetUploadsRequest>
        void ListMultipartReadSetUploadsAsync(const ListMultipartReadSetUploadsRequestT& request, const ListMultipartReadSetUploadsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListMultipartReadSetUploads, request, handler, context);
        }
 
        virtual Model::ListReadSetActivationJobsOutcome ListReadSetActivationJobs(const Model::ListReadSetActivationJobsRequest& request) const;
 
        template<typename ListReadSetActivationJobsRequestT = Model::ListReadSetActivationJobsRequest>
        Model::ListReadSetActivationJobsOutcomeCallable ListReadSetActivationJobsCallable(const ListReadSetActivationJobsRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListReadSetActivationJobs, request);
        }
 
        template<typename ListReadSetActivationJobsRequestT = Model::ListReadSetActivationJobsRequest>
        void ListReadSetActivationJobsAsync(const ListReadSetActivationJobsRequestT& request, const ListReadSetActivationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListReadSetActivationJobs, request, handler, context);
        }
 
        virtual Model::ListReadSetExportJobsOutcome ListReadSetExportJobs(const Model::ListReadSetExportJobsRequest& request) const;
 
        template<typename ListReadSetExportJobsRequestT = Model::ListReadSetExportJobsRequest>
        Model::ListReadSetExportJobsOutcomeCallable ListReadSetExportJobsCallable(const ListReadSetExportJobsRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListReadSetExportJobs, request);
        }
 
        template<typename ListReadSetExportJobsRequestT = Model::ListReadSetExportJobsRequest>
        void ListReadSetExportJobsAsync(const ListReadSetExportJobsRequestT& request, const ListReadSetExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListReadSetExportJobs, request, handler, context);
        }
 
        virtual Model::ListReadSetImportJobsOutcome ListReadSetImportJobs(const Model::ListReadSetImportJobsRequest& request) const;
 
        template<typename ListReadSetImportJobsRequestT = Model::ListReadSetImportJobsRequest>
        Model::ListReadSetImportJobsOutcomeCallable ListReadSetImportJobsCallable(const ListReadSetImportJobsRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListReadSetImportJobs, request);
        }
 
        template<typename ListReadSetImportJobsRequestT = Model::ListReadSetImportJobsRequest>
        void ListReadSetImportJobsAsync(const ListReadSetImportJobsRequestT& request, const ListReadSetImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListReadSetImportJobs, request, handler, context);
        }
 
        virtual Model::ListReadSetUploadPartsOutcome ListReadSetUploadParts(const Model::ListReadSetUploadPartsRequest& request) const;
 
        template<typename ListReadSetUploadPartsRequestT = Model::ListReadSetUploadPartsRequest>
        Model::ListReadSetUploadPartsOutcomeCallable ListReadSetUploadPartsCallable(const ListReadSetUploadPartsRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListReadSetUploadParts, request);
        }
 
        template<typename ListReadSetUploadPartsRequestT = Model::ListReadSetUploadPartsRequest>
        void ListReadSetUploadPartsAsync(const ListReadSetUploadPartsRequestT& request, const ListReadSetUploadPartsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListReadSetUploadParts, request, handler, context);
        }
 
        virtual Model::ListReadSetsOutcome ListReadSets(const Model::ListReadSetsRequest& request) const;
 
        template<typename ListReadSetsRequestT = Model::ListReadSetsRequest>
        Model::ListReadSetsOutcomeCallable ListReadSetsCallable(const ListReadSetsRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListReadSets, request);
        }
 
        template<typename ListReadSetsRequestT = Model::ListReadSetsRequest>
        void ListReadSetsAsync(const ListReadSetsRequestT& request, const ListReadSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListReadSets, request, handler, context);
        }
 
        virtual Model::ListReferenceImportJobsOutcome ListReferenceImportJobs(const Model::ListReferenceImportJobsRequest& request) const;
 
        template<typename ListReferenceImportJobsRequestT = Model::ListReferenceImportJobsRequest>
        Model::ListReferenceImportJobsOutcomeCallable ListReferenceImportJobsCallable(const ListReferenceImportJobsRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListReferenceImportJobs, request);
        }
 
        template<typename ListReferenceImportJobsRequestT = Model::ListReferenceImportJobsRequest>
        void ListReferenceImportJobsAsync(const ListReferenceImportJobsRequestT& request, const ListReferenceImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListReferenceImportJobs, request, handler, context);
        }
 
        virtual Model::ListReferenceStoresOutcome ListReferenceStores(const Model::ListReferenceStoresRequest& request = {}) const;
 
        template<typename ListReferenceStoresRequestT = Model::ListReferenceStoresRequest>
        Model::ListReferenceStoresOutcomeCallable ListReferenceStoresCallable(const ListReferenceStoresRequestT& request = {}) const
        {
            return SubmitCallable(&OmicsClient::ListReferenceStores, request);
        }
 
        template<typename ListReferenceStoresRequestT = Model::ListReferenceStoresRequest>
        void ListReferenceStoresAsync(const ListReferenceStoresResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReferenceStoresRequestT& request = {}) const
        {
            return SubmitAsync(&OmicsClient::ListReferenceStores, request, handler, context);
        }
 
        virtual Model::ListReferencesOutcome ListReferences(const Model::ListReferencesRequest& request) const;
 
        template<typename ListReferencesRequestT = Model::ListReferencesRequest>
        Model::ListReferencesOutcomeCallable ListReferencesCallable(const ListReferencesRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListReferences, request);
        }
 
        template<typename ListReferencesRequestT = Model::ListReferencesRequest>
        void ListReferencesAsync(const ListReferencesRequestT& request, const ListReferencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListReferences, request, handler, context);
        }
 
        virtual Model::ListRunCachesOutcome ListRunCaches(const Model::ListRunCachesRequest& request = {}) const;
 
        template<typename ListRunCachesRequestT = Model::ListRunCachesRequest>
        Model::ListRunCachesOutcomeCallable ListRunCachesCallable(const ListRunCachesRequestT& request = {}) const
        {
            return SubmitCallable(&OmicsClient::ListRunCaches, request);
        }
 
        template<typename ListRunCachesRequestT = Model::ListRunCachesRequest>
        void ListRunCachesAsync(const ListRunCachesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRunCachesRequestT& request = {}) const
        {
            return SubmitAsync(&OmicsClient::ListRunCaches, request, handler, context);
        }
 
        virtual Model::ListRunGroupsOutcome ListRunGroups(const Model::ListRunGroupsRequest& request = {}) const;
 
        template<typename ListRunGroupsRequestT = Model::ListRunGroupsRequest>
        Model::ListRunGroupsOutcomeCallable ListRunGroupsCallable(const ListRunGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&OmicsClient::ListRunGroups, request);
        }
 
        template<typename ListRunGroupsRequestT = Model::ListRunGroupsRequest>
        void ListRunGroupsAsync(const ListRunGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRunGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&OmicsClient::ListRunGroups, request, handler, context);
        }
 
        virtual Model::ListRunTasksOutcome ListRunTasks(const Model::ListRunTasksRequest& request) const;
 
        template<typename ListRunTasksRequestT = Model::ListRunTasksRequest>
        Model::ListRunTasksOutcomeCallable ListRunTasksCallable(const ListRunTasksRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListRunTasks, request);
        }
 
        template<typename ListRunTasksRequestT = Model::ListRunTasksRequest>
        void ListRunTasksAsync(const ListRunTasksRequestT& request, const ListRunTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListRunTasks, request, handler, context);
        }
 
        virtual Model::ListRunsOutcome ListRuns(const Model::ListRunsRequest& request = {}) const;
 
        template<typename ListRunsRequestT = Model::ListRunsRequest>
        Model::ListRunsOutcomeCallable ListRunsCallable(const ListRunsRequestT& request = {}) const
        {
            return SubmitCallable(&OmicsClient::ListRuns, request);
        }
 
        template<typename ListRunsRequestT = Model::ListRunsRequest>
        void ListRunsAsync(const ListRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRunsRequestT& request = {}) const
        {
            return SubmitAsync(&OmicsClient::ListRuns, request, handler, context);
        }
 
        virtual Model::ListSequenceStoresOutcome ListSequenceStores(const Model::ListSequenceStoresRequest& request = {}) const;
 
        template<typename ListSequenceStoresRequestT = Model::ListSequenceStoresRequest>
        Model::ListSequenceStoresOutcomeCallable ListSequenceStoresCallable(const ListSequenceStoresRequestT& request = {}) const
        {
            return SubmitCallable(&OmicsClient::ListSequenceStores, request);
        }
 
        template<typename ListSequenceStoresRequestT = Model::ListSequenceStoresRequest>
        void ListSequenceStoresAsync(const ListSequenceStoresResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSequenceStoresRequestT& request = {}) const
        {
            return SubmitAsync(&OmicsClient::ListSequenceStores, request, handler, context);
        }
 
        virtual Model::ListSharesOutcome ListShares(const Model::ListSharesRequest& request) const;
 
        template<typename ListSharesRequestT = Model::ListSharesRequest>
        Model::ListSharesOutcomeCallable ListSharesCallable(const ListSharesRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListShares, request);
        }
 
        template<typename ListSharesRequestT = Model::ListSharesRequest>
        void ListSharesAsync(const ListSharesRequestT& request, const ListSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListShares, 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(&OmicsClient::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(&OmicsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListVariantImportJobsOutcome ListVariantImportJobs(const Model::ListVariantImportJobsRequest& request = {}) const;
 
        template<typename ListVariantImportJobsRequestT = Model::ListVariantImportJobsRequest>
        Model::ListVariantImportJobsOutcomeCallable ListVariantImportJobsCallable(const ListVariantImportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&OmicsClient::ListVariantImportJobs, request);
        }
 
        template<typename ListVariantImportJobsRequestT = Model::ListVariantImportJobsRequest>
        void ListVariantImportJobsAsync(const ListVariantImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVariantImportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&OmicsClient::ListVariantImportJobs, request, handler, context);
        }
 
        virtual Model::ListVariantStoresOutcome ListVariantStores(const Model::ListVariantStoresRequest& request = {}) const;
 
        template<typename ListVariantStoresRequestT = Model::ListVariantStoresRequest>
        Model::ListVariantStoresOutcomeCallable ListVariantStoresCallable(const ListVariantStoresRequestT& request = {}) const
        {
            return SubmitCallable(&OmicsClient::ListVariantStores, request);
        }
 
        template<typename ListVariantStoresRequestT = Model::ListVariantStoresRequest>
        void ListVariantStoresAsync(const ListVariantStoresResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVariantStoresRequestT& request = {}) const
        {
            return SubmitAsync(&OmicsClient::ListVariantStores, request, handler, context);
        }
 
        virtual Model::ListWorkflowVersionsOutcome ListWorkflowVersions(const Model::ListWorkflowVersionsRequest& request) const;
 
        template<typename ListWorkflowVersionsRequestT = Model::ListWorkflowVersionsRequest>
        Model::ListWorkflowVersionsOutcomeCallable ListWorkflowVersionsCallable(const ListWorkflowVersionsRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::ListWorkflowVersions, request);
        }
 
        template<typename ListWorkflowVersionsRequestT = Model::ListWorkflowVersionsRequest>
        void ListWorkflowVersionsAsync(const ListWorkflowVersionsRequestT& request, const ListWorkflowVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::ListWorkflowVersions, request, handler, context);
        }
 
        virtual Model::ListWorkflowsOutcome ListWorkflows(const Model::ListWorkflowsRequest& request = {}) const;
 
        template<typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
        Model::ListWorkflowsOutcomeCallable ListWorkflowsCallable(const ListWorkflowsRequestT& request = {}) const
        {
            return SubmitCallable(&OmicsClient::ListWorkflows, request);
        }
 
        template<typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
        void ListWorkflowsAsync(const ListWorkflowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWorkflowsRequestT& request = {}) const
        {
            return SubmitAsync(&OmicsClient::ListWorkflows, request, handler, context);
        }
 
        virtual Model::PutS3AccessPolicyOutcome PutS3AccessPolicy(const Model::PutS3AccessPolicyRequest& request) const;
 
        template<typename PutS3AccessPolicyRequestT = Model::PutS3AccessPolicyRequest>
        Model::PutS3AccessPolicyOutcomeCallable PutS3AccessPolicyCallable(const PutS3AccessPolicyRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::PutS3AccessPolicy, request);
        }
 
        template<typename PutS3AccessPolicyRequestT = Model::PutS3AccessPolicyRequest>
        void PutS3AccessPolicyAsync(const PutS3AccessPolicyRequestT& request, const PutS3AccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::PutS3AccessPolicy, request, handler, context);
        }
 
        virtual Model::StartAnnotationImportJobOutcome StartAnnotationImportJob(const Model::StartAnnotationImportJobRequest& request) const;
 
        template<typename StartAnnotationImportJobRequestT = Model::StartAnnotationImportJobRequest>
        Model::StartAnnotationImportJobOutcomeCallable StartAnnotationImportJobCallable(const StartAnnotationImportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::StartAnnotationImportJob, request);
        }
 
        template<typename StartAnnotationImportJobRequestT = Model::StartAnnotationImportJobRequest>
        void StartAnnotationImportJobAsync(const StartAnnotationImportJobRequestT& request, const StartAnnotationImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::StartAnnotationImportJob, request, handler, context);
        }
 
        virtual Model::StartReadSetActivationJobOutcome StartReadSetActivationJob(const Model::StartReadSetActivationJobRequest& request) const;
 
        template<typename StartReadSetActivationJobRequestT = Model::StartReadSetActivationJobRequest>
        Model::StartReadSetActivationJobOutcomeCallable StartReadSetActivationJobCallable(const StartReadSetActivationJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::StartReadSetActivationJob, request);
        }
 
        template<typename StartReadSetActivationJobRequestT = Model::StartReadSetActivationJobRequest>
        void StartReadSetActivationJobAsync(const StartReadSetActivationJobRequestT& request, const StartReadSetActivationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::StartReadSetActivationJob, request, handler, context);
        }
 
        virtual Model::StartReadSetExportJobOutcome StartReadSetExportJob(const Model::StartReadSetExportJobRequest& request) const;
 
        template<typename StartReadSetExportJobRequestT = Model::StartReadSetExportJobRequest>
        Model::StartReadSetExportJobOutcomeCallable StartReadSetExportJobCallable(const StartReadSetExportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::StartReadSetExportJob, request);
        }
 
        template<typename StartReadSetExportJobRequestT = Model::StartReadSetExportJobRequest>
        void StartReadSetExportJobAsync(const StartReadSetExportJobRequestT& request, const StartReadSetExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::StartReadSetExportJob, request, handler, context);
        }
 
        virtual Model::StartReadSetImportJobOutcome StartReadSetImportJob(const Model::StartReadSetImportJobRequest& request) const;
 
        template<typename StartReadSetImportJobRequestT = Model::StartReadSetImportJobRequest>
        Model::StartReadSetImportJobOutcomeCallable StartReadSetImportJobCallable(const StartReadSetImportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::StartReadSetImportJob, request);
        }
 
        template<typename StartReadSetImportJobRequestT = Model::StartReadSetImportJobRequest>
        void StartReadSetImportJobAsync(const StartReadSetImportJobRequestT& request, const StartReadSetImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::StartReadSetImportJob, request, handler, context);
        }
 
        virtual Model::StartReferenceImportJobOutcome StartReferenceImportJob(const Model::StartReferenceImportJobRequest& request) const;
 
        template<typename StartReferenceImportJobRequestT = Model::StartReferenceImportJobRequest>
        Model::StartReferenceImportJobOutcomeCallable StartReferenceImportJobCallable(const StartReferenceImportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::StartReferenceImportJob, request);
        }
 
        template<typename StartReferenceImportJobRequestT = Model::StartReferenceImportJobRequest>
        void StartReferenceImportJobAsync(const StartReferenceImportJobRequestT& request, const StartReferenceImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::StartReferenceImportJob, request, handler, context);
        }
 
        virtual Model::StartRunOutcome StartRun(const Model::StartRunRequest& request) const;
 
        template<typename StartRunRequestT = Model::StartRunRequest>
        Model::StartRunOutcomeCallable StartRunCallable(const StartRunRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::StartRun, request);
        }
 
        template<typename StartRunRequestT = Model::StartRunRequest>
        void StartRunAsync(const StartRunRequestT& request, const StartRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::StartRun, request, handler, context);
        }
 
        virtual Model::StartVariantImportJobOutcome StartVariantImportJob(const Model::StartVariantImportJobRequest& request) const;
 
        template<typename StartVariantImportJobRequestT = Model::StartVariantImportJobRequest>
        Model::StartVariantImportJobOutcomeCallable StartVariantImportJobCallable(const StartVariantImportJobRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::StartVariantImportJob, request);
        }
 
        template<typename StartVariantImportJobRequestT = Model::StartVariantImportJobRequest>
        void StartVariantImportJobAsync(const StartVariantImportJobRequestT& request, const StartVariantImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::StartVariantImportJob, 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(&OmicsClient::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(&OmicsClient::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(&OmicsClient::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(&OmicsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAnnotationStoreOutcome UpdateAnnotationStore(const Model::UpdateAnnotationStoreRequest& request) const;
 
        template<typename UpdateAnnotationStoreRequestT = Model::UpdateAnnotationStoreRequest>
        Model::UpdateAnnotationStoreOutcomeCallable UpdateAnnotationStoreCallable(const UpdateAnnotationStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::UpdateAnnotationStore, request);
        }
 
        template<typename UpdateAnnotationStoreRequestT = Model::UpdateAnnotationStoreRequest>
        void UpdateAnnotationStoreAsync(const UpdateAnnotationStoreRequestT& request, const UpdateAnnotationStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::UpdateAnnotationStore, request, handler, context);
        }
 
        virtual Model::UpdateAnnotationStoreVersionOutcome UpdateAnnotationStoreVersion(const Model::UpdateAnnotationStoreVersionRequest& request) const;
 
        template<typename UpdateAnnotationStoreVersionRequestT = Model::UpdateAnnotationStoreVersionRequest>
        Model::UpdateAnnotationStoreVersionOutcomeCallable UpdateAnnotationStoreVersionCallable(const UpdateAnnotationStoreVersionRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::UpdateAnnotationStoreVersion, request);
        }
 
        template<typename UpdateAnnotationStoreVersionRequestT = Model::UpdateAnnotationStoreVersionRequest>
        void UpdateAnnotationStoreVersionAsync(const UpdateAnnotationStoreVersionRequestT& request, const UpdateAnnotationStoreVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::UpdateAnnotationStoreVersion, request, handler, context);
        }
 
        virtual Model::UpdateRunCacheOutcome UpdateRunCache(const Model::UpdateRunCacheRequest& request) const;
 
        template<typename UpdateRunCacheRequestT = Model::UpdateRunCacheRequest>
        Model::UpdateRunCacheOutcomeCallable UpdateRunCacheCallable(const UpdateRunCacheRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::UpdateRunCache, request);
        }
 
        template<typename UpdateRunCacheRequestT = Model::UpdateRunCacheRequest>
        void UpdateRunCacheAsync(const UpdateRunCacheRequestT& request, const UpdateRunCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::UpdateRunCache, request, handler, context);
        }
 
        virtual Model::UpdateRunGroupOutcome UpdateRunGroup(const Model::UpdateRunGroupRequest& request) const;
 
        template<typename UpdateRunGroupRequestT = Model::UpdateRunGroupRequest>
        Model::UpdateRunGroupOutcomeCallable UpdateRunGroupCallable(const UpdateRunGroupRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::UpdateRunGroup, request);
        }
 
        template<typename UpdateRunGroupRequestT = Model::UpdateRunGroupRequest>
        void UpdateRunGroupAsync(const UpdateRunGroupRequestT& request, const UpdateRunGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::UpdateRunGroup, request, handler, context);
        }
 
        virtual Model::UpdateSequenceStoreOutcome UpdateSequenceStore(const Model::UpdateSequenceStoreRequest& request) const;
 
        template<typename UpdateSequenceStoreRequestT = Model::UpdateSequenceStoreRequest>
        Model::UpdateSequenceStoreOutcomeCallable UpdateSequenceStoreCallable(const UpdateSequenceStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::UpdateSequenceStore, request);
        }
 
        template<typename UpdateSequenceStoreRequestT = Model::UpdateSequenceStoreRequest>
        void UpdateSequenceStoreAsync(const UpdateSequenceStoreRequestT& request, const UpdateSequenceStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::UpdateSequenceStore, request, handler, context);
        }
 
        virtual Model::UpdateVariantStoreOutcome UpdateVariantStore(const Model::UpdateVariantStoreRequest& request) const;
 
        template<typename UpdateVariantStoreRequestT = Model::UpdateVariantStoreRequest>
        Model::UpdateVariantStoreOutcomeCallable UpdateVariantStoreCallable(const UpdateVariantStoreRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::UpdateVariantStore, request);
        }
 
        template<typename UpdateVariantStoreRequestT = Model::UpdateVariantStoreRequest>
        void UpdateVariantStoreAsync(const UpdateVariantStoreRequestT& request, const UpdateVariantStoreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::UpdateVariantStore, request, handler, context);
        }
 
        virtual Model::UpdateWorkflowOutcome UpdateWorkflow(const Model::UpdateWorkflowRequest& request) const;
 
        template<typename UpdateWorkflowRequestT = Model::UpdateWorkflowRequest>
        Model::UpdateWorkflowOutcomeCallable UpdateWorkflowCallable(const UpdateWorkflowRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::UpdateWorkflow, request);
        }
 
        template<typename UpdateWorkflowRequestT = Model::UpdateWorkflowRequest>
        void UpdateWorkflowAsync(const UpdateWorkflowRequestT& request, const UpdateWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::UpdateWorkflow, request, handler, context);
        }
 
        virtual Model::UpdateWorkflowVersionOutcome UpdateWorkflowVersion(const Model::UpdateWorkflowVersionRequest& request) const;
 
        template<typename UpdateWorkflowVersionRequestT = Model::UpdateWorkflowVersionRequest>
        Model::UpdateWorkflowVersionOutcomeCallable UpdateWorkflowVersionCallable(const UpdateWorkflowVersionRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::UpdateWorkflowVersion, request);
        }
 
        template<typename UpdateWorkflowVersionRequestT = Model::UpdateWorkflowVersionRequest>
        void UpdateWorkflowVersionAsync(const UpdateWorkflowVersionRequestT& request, const UpdateWorkflowVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::UpdateWorkflowVersion, request, handler, context);
        }
 
        virtual Model::UploadReadSetPartOutcome UploadReadSetPart(const Model::UploadReadSetPartRequest& request) const;
 
        template<typename UploadReadSetPartRequestT = Model::UploadReadSetPartRequest>
        Model::UploadReadSetPartOutcomeCallable UploadReadSetPartCallable(const UploadReadSetPartRequestT& request) const
        {
            return SubmitCallable(&OmicsClient::UploadReadSetPart, request);
        }
 
        template<typename UploadReadSetPartRequestT = Model::UploadReadSetPartRequest>
        void UploadReadSetPartAsync(const UploadReadSetPartRequestT& request, const UploadReadSetPartResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&OmicsClient::UploadReadSetPart, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<OmicsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<OmicsClient>;
      void init(const OmicsClientConfiguration& clientConfiguration);
 
      OmicsClientConfiguration m_clientConfiguration;
      std::shared_ptr<OmicsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Omics
} // namespace Aws