OmicsClient.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/omics/OmicsPaginationBase.h>
#include <aws/omics/OmicsServiceClientModel.h>
#include <aws/omics/OmicsWaiter.h>
#include <aws/omics/Omics_EXPORTS.h>
 
namespace Aws {
namespace Omics {
class AWS_OMICS_API OmicsClient : public Aws::Client::AWSJsonClient,
                                  public Aws::Client::ClientWithAsyncTemplateMethods<OmicsClient>,
                                  public OmicsPaginationBase<OmicsClient>,
                                  public OmicsWaiter<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::CancelRunBatchOutcome CancelRunBatch(const Model::CancelRunBatchRequest& request) const;
 
  template <typename CancelRunBatchRequestT = Model::CancelRunBatchRequest>
  Model::CancelRunBatchOutcomeCallable CancelRunBatchCallable(const CancelRunBatchRequestT& request) const {
    return SubmitCallable(&OmicsClient::CancelRunBatch, request);
  }
 
  template <typename CancelRunBatchRequestT = Model::CancelRunBatchRequest>
  void CancelRunBatchAsync(const CancelRunBatchRequestT& request, const CancelRunBatchResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OmicsClient::CancelRunBatch, 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::CreateConfigurationOutcome CreateConfiguration(const Model::CreateConfigurationRequest& request) const;
 
  template <typename CreateConfigurationRequestT = Model::CreateConfigurationRequest>
  Model::CreateConfigurationOutcomeCallable CreateConfigurationCallable(const CreateConfigurationRequestT& request) const {
    return SubmitCallable(&OmicsClient::CreateConfiguration, request);
  }
 
  template <typename CreateConfigurationRequestT = Model::CreateConfigurationRequest>
  void CreateConfigurationAsync(const CreateConfigurationRequestT& request, const CreateConfigurationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OmicsClient::CreateConfiguration, 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::DeleteBatchOutcome DeleteBatch(const Model::DeleteBatchRequest& request) const;
 
  template <typename DeleteBatchRequestT = Model::DeleteBatchRequest>
  Model::DeleteBatchOutcomeCallable DeleteBatchCallable(const DeleteBatchRequestT& request) const {
    return SubmitCallable(&OmicsClient::DeleteBatch, request);
  }
 
  template <typename DeleteBatchRequestT = Model::DeleteBatchRequest>
  void DeleteBatchAsync(const DeleteBatchRequestT& request, const DeleteBatchResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OmicsClient::DeleteBatch, request, handler, context);
  }
 
  virtual Model::DeleteConfigurationOutcome DeleteConfiguration(const Model::DeleteConfigurationRequest& request) const;
 
  template <typename DeleteConfigurationRequestT = Model::DeleteConfigurationRequest>
  Model::DeleteConfigurationOutcomeCallable DeleteConfigurationCallable(const DeleteConfigurationRequestT& request) const {
    return SubmitCallable(&OmicsClient::DeleteConfiguration, request);
  }
 
  template <typename DeleteConfigurationRequestT = Model::DeleteConfigurationRequest>
  void DeleteConfigurationAsync(const DeleteConfigurationRequestT& request, const DeleteConfigurationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OmicsClient::DeleteConfiguration, 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::DeleteRunBatchOutcome DeleteRunBatch(const Model::DeleteRunBatchRequest& request) const;
 
  template <typename DeleteRunBatchRequestT = Model::DeleteRunBatchRequest>
  Model::DeleteRunBatchOutcomeCallable DeleteRunBatchCallable(const DeleteRunBatchRequestT& request) const {
    return SubmitCallable(&OmicsClient::DeleteRunBatch, request);
  }
 
  template <typename DeleteRunBatchRequestT = Model::DeleteRunBatchRequest>
  void DeleteRunBatchAsync(const DeleteRunBatchRequestT& request, const DeleteRunBatchResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OmicsClient::DeleteRunBatch, 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::GetBatchOutcome GetBatch(const Model::GetBatchRequest& request) const;
 
  template <typename GetBatchRequestT = Model::GetBatchRequest>
  Model::GetBatchOutcomeCallable GetBatchCallable(const GetBatchRequestT& request) const {
    return SubmitCallable(&OmicsClient::GetBatch, request);
  }
 
  template <typename GetBatchRequestT = Model::GetBatchRequest>
  void GetBatchAsync(const GetBatchRequestT& request, const GetBatchResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OmicsClient::GetBatch, request, handler, context);
  }
 
  virtual Model::GetConfigurationOutcome GetConfiguration(const Model::GetConfigurationRequest& request) const;
 
  template <typename GetConfigurationRequestT = Model::GetConfigurationRequest>
  Model::GetConfigurationOutcomeCallable GetConfigurationCallable(const GetConfigurationRequestT& request) const {
    return SubmitCallable(&OmicsClient::GetConfiguration, request);
  }
 
  template <typename GetConfigurationRequestT = Model::GetConfigurationRequest>
  void GetConfigurationAsync(const GetConfigurationRequestT& request, const GetConfigurationResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OmicsClient::GetConfiguration, 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::ListBatchOutcome ListBatch(const Model::ListBatchRequest& request = {}) const;
 
  template <typename ListBatchRequestT = Model::ListBatchRequest>
  Model::ListBatchOutcomeCallable ListBatchCallable(const ListBatchRequestT& request = {}) const {
    return SubmitCallable(&OmicsClient::ListBatch, request);
  }
 
  template <typename ListBatchRequestT = Model::ListBatchRequest>
  void ListBatchAsync(const ListBatchResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListBatchRequestT& request = {}) const {
    return SubmitAsync(&OmicsClient::ListBatch, request, handler, context);
  }
 
  virtual Model::ListConfigurationsOutcome ListConfigurations(const Model::ListConfigurationsRequest& request = {}) const;
 
  template <typename ListConfigurationsRequestT = Model::ListConfigurationsRequest>
  Model::ListConfigurationsOutcomeCallable ListConfigurationsCallable(const ListConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&OmicsClient::ListConfigurations, request);
  }
 
  template <typename ListConfigurationsRequestT = Model::ListConfigurationsRequest>
  void ListConfigurationsAsync(const ListConfigurationsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&OmicsClient::ListConfigurations, 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::ListRunsInBatchOutcome ListRunsInBatch(const Model::ListRunsInBatchRequest& request) const;
 
  template <typename ListRunsInBatchRequestT = Model::ListRunsInBatchRequest>
  Model::ListRunsInBatchOutcomeCallable ListRunsInBatchCallable(const ListRunsInBatchRequestT& request) const {
    return SubmitCallable(&OmicsClient::ListRunsInBatch, request);
  }
 
  template <typename ListRunsInBatchRequestT = Model::ListRunsInBatchRequest>
  void ListRunsInBatchAsync(const ListRunsInBatchRequestT& request, const ListRunsInBatchResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OmicsClient::ListRunsInBatch, 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::StartRunBatchOutcome StartRunBatch(const Model::StartRunBatchRequest& request) const;
 
  template <typename StartRunBatchRequestT = Model::StartRunBatchRequest>
  Model::StartRunBatchOutcomeCallable StartRunBatchCallable(const StartRunBatchRequestT& request) const {
    return SubmitCallable(&OmicsClient::StartRunBatch, request);
  }
 
  template <typename StartRunBatchRequestT = Model::StartRunBatchRequest>
  void StartRunBatchAsync(const StartRunBatchRequestT& request, const StartRunBatchResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OmicsClient::StartRunBatch, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<OmicsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<OmicsClient>;
  void init(const OmicsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, OmicsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  OmicsClientConfiguration m_clientConfiguration;
  std::shared_ptr<OmicsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Omics
}  // namespace Aws