/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the omics-2022-11-28.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.Omics.Model; using Amazon.Omics.Model.Internal.MarshallTransformations; using Amazon.Omics.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.Omics { ///

/// Implementation for accessing Omics /// /// This is the AWS HealthOmics API Reference. For an introduction to the service, /// see What is AWS HealthOmics? /// in the AWS HealthOmics User Guide. ///

public partial class AmazonOmicsClient : AmazonServiceClient, IAmazonOmics { private static IServiceMetadata serviceMetadata = new AmazonOmicsMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private IOmicsPaginatorFactory _paginators; ///

/// Paginators for the service ///

public IOmicsPaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new OmicsPaginatorFactory(this); } return this._paginators; } } #endif #region Constructors ///

/// Constructs AmazonOmicsClient with the credentials loaded from the application's /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. /// /// Example App.config with credentials set. ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

public AmazonOmicsClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonOmicsConfig()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonOmicsClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonOmicsConfig{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonOmicsClient Configuration Object public AmazonOmicsClient(AmazonOmicsConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonOmicsClient with AWS Credentials ///

/// AWS Credentials public AmazonOmicsClient(AWSCredentials credentials) : this(credentials, new AmazonOmicsConfig()) { } ///

/// Constructs AmazonOmicsClient with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonOmicsClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonOmicsConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonOmicsClient with AWS Credentials and an /// AmazonOmicsClient Configuration object. ///

/// AWS Credentials /// The AmazonOmicsClient Configuration Object public AmazonOmicsClient(AWSCredentials credentials, AmazonOmicsConfig clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonOmicsClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonOmicsClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonOmicsConfig()) { } ///

/// Constructs AmazonOmicsClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonOmicsClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonOmicsConfig() {RegionEndpoint=region}) { } ///

/// Constructs AmazonOmicsClient with AWS Access Key ID, AWS Secret Key and an /// AmazonOmicsClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonOmicsClient Configuration Object public AmazonOmicsClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonOmicsConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonOmicsClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonOmicsClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonOmicsConfig()) { } ///

/// Constructs AmazonOmicsClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The region to connect. public AmazonOmicsClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonOmicsConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonOmicsClient with AWS Access Key ID, AWS Secret Key and an /// AmazonOmicsClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonOmicsClient Configuration Object public AmazonOmicsClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonOmicsConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customize the pipeline ///

/// protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonOmicsEndpointResolver()); } ///

/// Capture metadata for the service. ///

protected override IServiceMetadata ServiceMetadata { get { return serviceMetadata; } } #endregion #region Dispose ///

/// Disposes the service client. ///

protected override void Dispose(bool disposing) { base.Dispose(disposing); } #endregion #region AbortMultipartReadSetUpload ///

/// Stops a multipart upload. ///

/// Container for the necessary parameters to execute the AbortMultipartReadSetUpload service method. /// /// The response from the AbortMultipartReadSetUpload service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The operation is not supported by Amazon Omics, or the API does not exist. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for AbortMultipartReadSetUpload Operation public virtual AbortMultipartReadSetUploadResponse AbortMultipartReadSetUpload(AbortMultipartReadSetUploadRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AbortMultipartReadSetUploadRequestMarshaller.Instance; options.ResponseUnmarshaller = AbortMultipartReadSetUploadResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AbortMultipartReadSetUpload operation. ///

/// /// Container for the necessary parameters to execute the AbortMultipartReadSetUpload operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAbortMultipartReadSetUpload /// operation. /// REST API Reference for AbortMultipartReadSetUpload Operation public virtual IAsyncResult BeginAbortMultipartReadSetUpload(AbortMultipartReadSetUploadRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AbortMultipartReadSetUploadRequestMarshaller.Instance; options.ResponseUnmarshaller = AbortMultipartReadSetUploadResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AbortMultipartReadSetUpload operation. ///

/// /// The IAsyncResult returned by the call to BeginAbortMultipartReadSetUpload. /// /// Returns a AbortMultipartReadSetUploadResult from Omics. /// REST API Reference for AbortMultipartReadSetUpload Operation public virtual AbortMultipartReadSetUploadResponse EndAbortMultipartReadSetUpload(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region BatchDeleteReadSet ///

/// Deletes one or more read sets. ///

/// Container for the necessary parameters to execute the BatchDeleteReadSet service method. /// /// The response from the BatchDeleteReadSet service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for BatchDeleteReadSet Operation public virtual BatchDeleteReadSetResponse BatchDeleteReadSet(BatchDeleteReadSetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BatchDeleteReadSetRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchDeleteReadSetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the BatchDeleteReadSet operation. ///

/// /// Container for the necessary parameters to execute the BatchDeleteReadSet operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchDeleteReadSet /// operation. /// REST API Reference for BatchDeleteReadSet Operation public virtual IAsyncResult BeginBatchDeleteReadSet(BatchDeleteReadSetRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = BatchDeleteReadSetRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchDeleteReadSetResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the BatchDeleteReadSet operation. ///

/// /// The IAsyncResult returned by the call to BeginBatchDeleteReadSet. /// /// Returns a BatchDeleteReadSetResult from Omics. /// REST API Reference for BatchDeleteReadSet Operation public virtual BatchDeleteReadSetResponse EndBatchDeleteReadSet(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CancelAnnotationImportJob ///

/// Cancels an annotation import job. ///

/// Container for the necessary parameters to execute the CancelAnnotationImportJob service method. /// /// The response from the CancelAnnotationImportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CancelAnnotationImportJob Operation public virtual CancelAnnotationImportJobResponse CancelAnnotationImportJob(CancelAnnotationImportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelAnnotationImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelAnnotationImportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CancelAnnotationImportJob operation. ///

/// /// Container for the necessary parameters to execute the CancelAnnotationImportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelAnnotationImportJob /// operation. /// REST API Reference for CancelAnnotationImportJob Operation public virtual IAsyncResult BeginCancelAnnotationImportJob(CancelAnnotationImportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CancelAnnotationImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelAnnotationImportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CancelAnnotationImportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginCancelAnnotationImportJob. /// /// Returns a CancelAnnotationImportJobResult from Omics. /// REST API Reference for CancelAnnotationImportJob Operation public virtual CancelAnnotationImportJobResponse EndCancelAnnotationImportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CancelRun ///

/// Cancels a run. ///

/// Container for the necessary parameters to execute the CancelRun service method. /// /// The response from the CancelRun service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CancelRun Operation public virtual CancelRunResponse CancelRun(CancelRunRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelRunRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelRunResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CancelRun operation. ///

/// /// Container for the necessary parameters to execute the CancelRun operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelRun /// operation. /// REST API Reference for CancelRun Operation public virtual IAsyncResult BeginCancelRun(CancelRunRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CancelRunRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelRunResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CancelRun operation. ///

/// /// The IAsyncResult returned by the call to BeginCancelRun. /// /// Returns a CancelRunResult from Omics. /// REST API Reference for CancelRun Operation public virtual CancelRunResponse EndCancelRun(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CancelVariantImportJob ///

/// Cancels a variant import job. ///

/// Container for the necessary parameters to execute the CancelVariantImportJob service method. /// /// The response from the CancelVariantImportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CancelVariantImportJob Operation public virtual CancelVariantImportJobResponse CancelVariantImportJob(CancelVariantImportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelVariantImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelVariantImportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CancelVariantImportJob operation. ///

/// /// Container for the necessary parameters to execute the CancelVariantImportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelVariantImportJob /// operation. /// REST API Reference for CancelVariantImportJob Operation public virtual IAsyncResult BeginCancelVariantImportJob(CancelVariantImportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CancelVariantImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelVariantImportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CancelVariantImportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginCancelVariantImportJob. /// /// Returns a CancelVariantImportJobResult from Omics. /// REST API Reference for CancelVariantImportJob Operation public virtual CancelVariantImportJobResponse EndCancelVariantImportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CompleteMultipartReadSetUpload ///

/// Concludes a multipart upload once you have uploaded all the components. ///

/// Container for the necessary parameters to execute the CompleteMultipartReadSetUpload service method. /// /// The response from the CompleteMultipartReadSetUpload service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The operation is not supported by Amazon Omics, or the API does not exist. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CompleteMultipartReadSetUpload Operation public virtual CompleteMultipartReadSetUploadResponse CompleteMultipartReadSetUpload(CompleteMultipartReadSetUploadRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CompleteMultipartReadSetUploadRequestMarshaller.Instance; options.ResponseUnmarshaller = CompleteMultipartReadSetUploadResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CompleteMultipartReadSetUpload operation. ///

/// /// Container for the necessary parameters to execute the CompleteMultipartReadSetUpload operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCompleteMultipartReadSetUpload /// operation. /// REST API Reference for CompleteMultipartReadSetUpload Operation public virtual IAsyncResult BeginCompleteMultipartReadSetUpload(CompleteMultipartReadSetUploadRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CompleteMultipartReadSetUploadRequestMarshaller.Instance; options.ResponseUnmarshaller = CompleteMultipartReadSetUploadResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CompleteMultipartReadSetUpload operation. ///

/// /// The IAsyncResult returned by the call to BeginCompleteMultipartReadSetUpload. /// /// Returns a CompleteMultipartReadSetUploadResult from Omics. /// REST API Reference for CompleteMultipartReadSetUpload Operation public virtual CompleteMultipartReadSetUploadResponse EndCompleteMultipartReadSetUpload(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateAnnotationStore ///

/// Creates an annotation store. ///

/// Container for the necessary parameters to execute the CreateAnnotationStore service method. /// /// The response from the CreateAnnotationStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateAnnotationStore Operation public virtual CreateAnnotationStoreResponse CreateAnnotationStore(CreateAnnotationStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAnnotationStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAnnotationStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateAnnotationStore operation. ///

/// /// Container for the necessary parameters to execute the CreateAnnotationStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateAnnotationStore /// operation. /// REST API Reference for CreateAnnotationStore Operation public virtual IAsyncResult BeginCreateAnnotationStore(CreateAnnotationStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAnnotationStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAnnotationStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateAnnotationStore operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateAnnotationStore. /// /// Returns a CreateAnnotationStoreResult from Omics. /// REST API Reference for CreateAnnotationStore Operation public virtual CreateAnnotationStoreResponse EndCreateAnnotationStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateMultipartReadSetUpload ///

/// Begins a multipart read set upload. ///

/// Container for the necessary parameters to execute the CreateMultipartReadSetUpload service method. /// /// The response from the CreateMultipartReadSetUpload service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The operation is not supported by Amazon Omics, or the API does not exist. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateMultipartReadSetUpload Operation public virtual CreateMultipartReadSetUploadResponse CreateMultipartReadSetUpload(CreateMultipartReadSetUploadRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMultipartReadSetUploadRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMultipartReadSetUploadResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateMultipartReadSetUpload operation. ///

/// /// Container for the necessary parameters to execute the CreateMultipartReadSetUpload operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateMultipartReadSetUpload /// operation. /// REST API Reference for CreateMultipartReadSetUpload Operation public virtual IAsyncResult BeginCreateMultipartReadSetUpload(CreateMultipartReadSetUploadRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMultipartReadSetUploadRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMultipartReadSetUploadResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateMultipartReadSetUpload operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateMultipartReadSetUpload. /// /// Returns a CreateMultipartReadSetUploadResult from Omics. /// REST API Reference for CreateMultipartReadSetUpload Operation public virtual CreateMultipartReadSetUploadResponse EndCreateMultipartReadSetUpload(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateReferenceStore ///

/// Creates a reference store. ///

/// Container for the necessary parameters to execute the CreateReferenceStore service method. /// /// The response from the CreateReferenceStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateReferenceStore Operation public virtual CreateReferenceStoreResponse CreateReferenceStore(CreateReferenceStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateReferenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateReferenceStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateReferenceStore operation. ///

/// /// Container for the necessary parameters to execute the CreateReferenceStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateReferenceStore /// operation. /// REST API Reference for CreateReferenceStore Operation public virtual IAsyncResult BeginCreateReferenceStore(CreateReferenceStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateReferenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateReferenceStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateReferenceStore operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateReferenceStore. /// /// Returns a CreateReferenceStoreResult from Omics. /// REST API Reference for CreateReferenceStore Operation public virtual CreateReferenceStoreResponse EndCreateReferenceStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateRunGroup ///

/// Creates a run group. ///

/// Container for the necessary parameters to execute the CreateRunGroup service method. /// /// The response from the CreateRunGroup service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateRunGroup Operation public virtual CreateRunGroupResponse CreateRunGroup(CreateRunGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRunGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRunGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateRunGroup operation. ///

/// /// Container for the necessary parameters to execute the CreateRunGroup operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateRunGroup /// operation. /// REST API Reference for CreateRunGroup Operation public virtual IAsyncResult BeginCreateRunGroup(CreateRunGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRunGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRunGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateRunGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateRunGroup. /// /// Returns a CreateRunGroupResult from Omics. /// REST API Reference for CreateRunGroup Operation public virtual CreateRunGroupResponse EndCreateRunGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateSequenceStore ///

/// Creates a sequence store. ///

/// Container for the necessary parameters to execute the CreateSequenceStore service method. /// /// The response from the CreateSequenceStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateSequenceStore Operation public virtual CreateSequenceStoreResponse CreateSequenceStore(CreateSequenceStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSequenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSequenceStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateSequenceStore operation. ///

/// /// Container for the necessary parameters to execute the CreateSequenceStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSequenceStore /// operation. /// REST API Reference for CreateSequenceStore Operation public virtual IAsyncResult BeginCreateSequenceStore(CreateSequenceStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSequenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSequenceStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateSequenceStore operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateSequenceStore. /// /// Returns a CreateSequenceStoreResult from Omics. /// REST API Reference for CreateSequenceStore Operation public virtual CreateSequenceStoreResponse EndCreateSequenceStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateVariantStore ///

/// Creates a variant store. ///

/// Container for the necessary parameters to execute the CreateVariantStore service method. /// /// The response from the CreateVariantStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateVariantStore Operation public virtual CreateVariantStoreResponse CreateVariantStore(CreateVariantStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVariantStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVariantStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateVariantStore operation. ///

/// /// Container for the necessary parameters to execute the CreateVariantStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVariantStore /// operation. /// REST API Reference for CreateVariantStore Operation public virtual IAsyncResult BeginCreateVariantStore(CreateVariantStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVariantStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVariantStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateVariantStore operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateVariantStore. /// /// Returns a CreateVariantStoreResult from Omics. /// REST API Reference for CreateVariantStore Operation public virtual CreateVariantStoreResponse EndCreateVariantStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateWorkflow ///

/// Creates a workflow. ///

/// Container for the necessary parameters to execute the CreateWorkflow service method. /// /// The response from the CreateWorkflow service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateWorkflow Operation public virtual CreateWorkflowResponse CreateWorkflow(CreateWorkflowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkflowRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkflowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateWorkflow operation. ///

/// /// Container for the necessary parameters to execute the CreateWorkflow operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateWorkflow /// operation. /// REST API Reference for CreateWorkflow Operation public virtual IAsyncResult BeginCreateWorkflow(CreateWorkflowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkflowRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkflowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateWorkflow operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateWorkflow. /// /// Returns a CreateWorkflowResult from Omics. /// REST API Reference for CreateWorkflow Operation public virtual CreateWorkflowResponse EndCreateWorkflow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteAnnotationStore ///

/// Deletes an annotation store. ///

/// Container for the necessary parameters to execute the DeleteAnnotationStore service method. /// /// The response from the DeleteAnnotationStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteAnnotationStore Operation public virtual DeleteAnnotationStoreResponse DeleteAnnotationStore(DeleteAnnotationStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAnnotationStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAnnotationStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteAnnotationStore operation. ///

/// /// Container for the necessary parameters to execute the DeleteAnnotationStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteAnnotationStore /// operation. /// REST API Reference for DeleteAnnotationStore Operation public virtual IAsyncResult BeginDeleteAnnotationStore(DeleteAnnotationStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAnnotationStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAnnotationStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteAnnotationStore operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteAnnotationStore. /// /// Returns a DeleteAnnotationStoreResult from Omics. /// REST API Reference for DeleteAnnotationStore Operation public virtual DeleteAnnotationStoreResponse EndDeleteAnnotationStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteReference ///

/// Deletes a genome reference. ///

/// Container for the necessary parameters to execute the DeleteReference service method. /// /// The response from the DeleteReference service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteReference Operation public virtual DeleteReferenceResponse DeleteReference(DeleteReferenceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteReferenceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteReferenceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteReference operation. ///

/// /// Container for the necessary parameters to execute the DeleteReference operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteReference /// operation. /// REST API Reference for DeleteReference Operation public virtual IAsyncResult BeginDeleteReference(DeleteReferenceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteReferenceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteReferenceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteReference operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteReference. /// /// Returns a DeleteReferenceResult from Omics. /// REST API Reference for DeleteReference Operation public virtual DeleteReferenceResponse EndDeleteReference(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteReferenceStore ///

/// Deletes a genome reference store. ///

/// Container for the necessary parameters to execute the DeleteReferenceStore service method. /// /// The response from the DeleteReferenceStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteReferenceStore Operation public virtual DeleteReferenceStoreResponse DeleteReferenceStore(DeleteReferenceStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteReferenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteReferenceStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteReferenceStore operation. ///

/// /// Container for the necessary parameters to execute the DeleteReferenceStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteReferenceStore /// operation. /// REST API Reference for DeleteReferenceStore Operation public virtual IAsyncResult BeginDeleteReferenceStore(DeleteReferenceStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteReferenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteReferenceStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteReferenceStore operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteReferenceStore. /// /// Returns a DeleteReferenceStoreResult from Omics. /// REST API Reference for DeleteReferenceStore Operation public virtual DeleteReferenceStoreResponse EndDeleteReferenceStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteRun ///

/// Deletes a workflow run. ///

/// Container for the necessary parameters to execute the DeleteRun service method. /// /// The response from the DeleteRun service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteRun Operation public virtual DeleteRunResponse DeleteRun(DeleteRunRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRunRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRunResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteRun operation. ///

/// /// Container for the necessary parameters to execute the DeleteRun operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteRun /// operation. /// REST API Reference for DeleteRun Operation public virtual IAsyncResult BeginDeleteRun(DeleteRunRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRunRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRunResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteRun operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteRun. /// /// Returns a DeleteRunResult from Omics. /// REST API Reference for DeleteRun Operation public virtual DeleteRunResponse EndDeleteRun(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteRunGroup ///

/// Deletes a workflow run group. ///

/// Container for the necessary parameters to execute the DeleteRunGroup service method. /// /// The response from the DeleteRunGroup service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteRunGroup Operation public virtual DeleteRunGroupResponse DeleteRunGroup(DeleteRunGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRunGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRunGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteRunGroup operation. ///

/// /// Container for the necessary parameters to execute the DeleteRunGroup operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteRunGroup /// operation. /// REST API Reference for DeleteRunGroup Operation public virtual IAsyncResult BeginDeleteRunGroup(DeleteRunGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRunGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRunGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteRunGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteRunGroup. /// /// Returns a DeleteRunGroupResult from Omics. /// REST API Reference for DeleteRunGroup Operation public virtual DeleteRunGroupResponse EndDeleteRunGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteSequenceStore ///

/// Deletes a sequence store. ///

/// Container for the necessary parameters to execute the DeleteSequenceStore service method. /// /// The response from the DeleteSequenceStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteSequenceStore Operation public virtual DeleteSequenceStoreResponse DeleteSequenceStore(DeleteSequenceStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSequenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSequenceStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteSequenceStore operation. ///

/// /// Container for the necessary parameters to execute the DeleteSequenceStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteSequenceStore /// operation. /// REST API Reference for DeleteSequenceStore Operation public virtual IAsyncResult BeginDeleteSequenceStore(DeleteSequenceStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSequenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSequenceStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteSequenceStore operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteSequenceStore. /// /// Returns a DeleteSequenceStoreResult from Omics. /// REST API Reference for DeleteSequenceStore Operation public virtual DeleteSequenceStoreResponse EndDeleteSequenceStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteVariantStore ///

/// Deletes a variant store. ///

/// Container for the necessary parameters to execute the DeleteVariantStore service method. /// /// The response from the DeleteVariantStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteVariantStore Operation public virtual DeleteVariantStoreResponse DeleteVariantStore(DeleteVariantStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteVariantStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteVariantStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteVariantStore operation. ///

/// /// Container for the necessary parameters to execute the DeleteVariantStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVariantStore /// operation. /// REST API Reference for DeleteVariantStore Operation public virtual IAsyncResult BeginDeleteVariantStore(DeleteVariantStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteVariantStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteVariantStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteVariantStore operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteVariantStore. /// /// Returns a DeleteVariantStoreResult from Omics. /// REST API Reference for DeleteVariantStore Operation public virtual DeleteVariantStoreResponse EndDeleteVariantStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteWorkflow ///

/// Deletes a workflow. ///

/// Container for the necessary parameters to execute the DeleteWorkflow service method. /// /// The response from the DeleteWorkflow service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteWorkflow Operation public virtual DeleteWorkflowResponse DeleteWorkflow(DeleteWorkflowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkflowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkflowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteWorkflow operation. ///

/// /// Container for the necessary parameters to execute the DeleteWorkflow operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteWorkflow /// operation. /// REST API Reference for DeleteWorkflow Operation public virtual IAsyncResult BeginDeleteWorkflow(DeleteWorkflowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkflowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkflowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteWorkflow operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteWorkflow. /// /// Returns a DeleteWorkflowResult from Omics. /// REST API Reference for DeleteWorkflow Operation public virtual DeleteWorkflowResponse EndDeleteWorkflow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetAnnotationImportJob ///

/// Gets information about an annotation import job. ///

/// Container for the necessary parameters to execute the GetAnnotationImportJob service method. /// /// The response from the GetAnnotationImportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetAnnotationImportJob Operation public virtual GetAnnotationImportJobResponse GetAnnotationImportJob(GetAnnotationImportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAnnotationImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAnnotationImportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetAnnotationImportJob operation. ///

/// /// Container for the necessary parameters to execute the GetAnnotationImportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAnnotationImportJob /// operation. /// REST API Reference for GetAnnotationImportJob Operation public virtual IAsyncResult BeginGetAnnotationImportJob(GetAnnotationImportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetAnnotationImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAnnotationImportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetAnnotationImportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginGetAnnotationImportJob. /// /// Returns a GetAnnotationImportJobResult from Omics. /// REST API Reference for GetAnnotationImportJob Operation public virtual GetAnnotationImportJobResponse EndGetAnnotationImportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetAnnotationStore ///

/// Gets information about an annotation store. ///

/// Container for the necessary parameters to execute the GetAnnotationStore service method. /// /// The response from the GetAnnotationStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetAnnotationStore Operation public virtual GetAnnotationStoreResponse GetAnnotationStore(GetAnnotationStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAnnotationStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAnnotationStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetAnnotationStore operation. ///

/// /// Container for the necessary parameters to execute the GetAnnotationStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAnnotationStore /// operation. /// REST API Reference for GetAnnotationStore Operation public virtual IAsyncResult BeginGetAnnotationStore(GetAnnotationStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetAnnotationStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAnnotationStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetAnnotationStore operation. ///

/// /// The IAsyncResult returned by the call to BeginGetAnnotationStore. /// /// Returns a GetAnnotationStoreResult from Omics. /// REST API Reference for GetAnnotationStore Operation public virtual GetAnnotationStoreResponse EndGetAnnotationStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetReadSet ///

/// Gets a file from a read set. ///

/// Container for the necessary parameters to execute the GetReadSet service method. /// /// The response from the GetReadSet service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The ranges specified in the request are not valid. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetReadSet Operation public virtual GetReadSetResponse GetReadSet(GetReadSetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetReadSetRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReadSetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetReadSet operation. ///

/// /// Container for the necessary parameters to execute the GetReadSet operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetReadSet /// operation. /// REST API Reference for GetReadSet Operation public virtual IAsyncResult BeginGetReadSet(GetReadSetRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetReadSetRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReadSetResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetReadSet operation. ///

/// /// The IAsyncResult returned by the call to BeginGetReadSet. /// /// Returns a GetReadSetResult from Omics. /// REST API Reference for GetReadSet Operation public virtual GetReadSetResponse EndGetReadSet(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetReadSetActivationJob ///

/// Gets information about a read set activation job. ///

/// Container for the necessary parameters to execute the GetReadSetActivationJob service method. /// /// The response from the GetReadSetActivationJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetReadSetActivationJob Operation public virtual GetReadSetActivationJobResponse GetReadSetActivationJob(GetReadSetActivationJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetReadSetActivationJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReadSetActivationJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetReadSetActivationJob operation. ///

/// /// Container for the necessary parameters to execute the GetReadSetActivationJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetReadSetActivationJob /// operation. /// REST API Reference for GetReadSetActivationJob Operation public virtual IAsyncResult BeginGetReadSetActivationJob(GetReadSetActivationJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetReadSetActivationJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReadSetActivationJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetReadSetActivationJob operation. ///

/// /// The IAsyncResult returned by the call to BeginGetReadSetActivationJob. /// /// Returns a GetReadSetActivationJobResult from Omics. /// REST API Reference for GetReadSetActivationJob Operation public virtual GetReadSetActivationJobResponse EndGetReadSetActivationJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetReadSetExportJob ///

/// Gets information about a read set export job. ///

/// Container for the necessary parameters to execute the GetReadSetExportJob service method. /// /// The response from the GetReadSetExportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetReadSetExportJob Operation public virtual GetReadSetExportJobResponse GetReadSetExportJob(GetReadSetExportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetReadSetExportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReadSetExportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetReadSetExportJob operation. ///

/// /// Container for the necessary parameters to execute the GetReadSetExportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetReadSetExportJob /// operation. /// REST API Reference for GetReadSetExportJob Operation public virtual IAsyncResult BeginGetReadSetExportJob(GetReadSetExportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetReadSetExportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReadSetExportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetReadSetExportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginGetReadSetExportJob. /// /// Returns a GetReadSetExportJobResult from Omics. /// REST API Reference for GetReadSetExportJob Operation public virtual GetReadSetExportJobResponse EndGetReadSetExportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetReadSetImportJob ///

/// Gets information about a read set import job. ///

/// Container for the necessary parameters to execute the GetReadSetImportJob service method. /// /// The response from the GetReadSetImportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetReadSetImportJob Operation public virtual GetReadSetImportJobResponse GetReadSetImportJob(GetReadSetImportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetReadSetImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReadSetImportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetReadSetImportJob operation. ///

/// /// Container for the necessary parameters to execute the GetReadSetImportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetReadSetImportJob /// operation. /// REST API Reference for GetReadSetImportJob Operation public virtual IAsyncResult BeginGetReadSetImportJob(GetReadSetImportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetReadSetImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReadSetImportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetReadSetImportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginGetReadSetImportJob. /// /// Returns a GetReadSetImportJobResult from Omics. /// REST API Reference for GetReadSetImportJob Operation public virtual GetReadSetImportJobResponse EndGetReadSetImportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetReadSetMetadata ///

/// Gets details about a read set. ///

/// Container for the necessary parameters to execute the GetReadSetMetadata service method. /// /// The response from the GetReadSetMetadata service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetReadSetMetadata Operation public virtual GetReadSetMetadataResponse GetReadSetMetadata(GetReadSetMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetReadSetMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReadSetMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetReadSetMetadata operation. ///

/// /// Container for the necessary parameters to execute the GetReadSetMetadata operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetReadSetMetadata /// operation. /// REST API Reference for GetReadSetMetadata Operation public virtual IAsyncResult BeginGetReadSetMetadata(GetReadSetMetadataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetReadSetMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReadSetMetadataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetReadSetMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginGetReadSetMetadata. /// /// Returns a GetReadSetMetadataResult from Omics. /// REST API Reference for GetReadSetMetadata Operation public virtual GetReadSetMetadataResponse EndGetReadSetMetadata(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetReference ///

/// Gets a reference file. ///

/// Container for the necessary parameters to execute the GetReference service method. /// /// The response from the GetReference service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The ranges specified in the request are not valid. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetReference Operation public virtual GetReferenceResponse GetReference(GetReferenceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetReferenceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReferenceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetReference operation. ///

/// /// Container for the necessary parameters to execute the GetReference operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetReference /// operation. /// REST API Reference for GetReference Operation public virtual IAsyncResult BeginGetReference(GetReferenceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetReferenceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReferenceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetReference operation. ///

/// /// The IAsyncResult returned by the call to BeginGetReference. /// /// Returns a GetReferenceResult from Omics. /// REST API Reference for GetReference Operation public virtual GetReferenceResponse EndGetReference(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetReferenceImportJob ///

/// Gets information about a reference import job. ///

/// Container for the necessary parameters to execute the GetReferenceImportJob service method. /// /// The response from the GetReferenceImportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetReferenceImportJob Operation public virtual GetReferenceImportJobResponse GetReferenceImportJob(GetReferenceImportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetReferenceImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReferenceImportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetReferenceImportJob operation. ///

/// /// Container for the necessary parameters to execute the GetReferenceImportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetReferenceImportJob /// operation. /// REST API Reference for GetReferenceImportJob Operation public virtual IAsyncResult BeginGetReferenceImportJob(GetReferenceImportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetReferenceImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReferenceImportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetReferenceImportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginGetReferenceImportJob. /// /// Returns a GetReferenceImportJobResult from Omics. /// REST API Reference for GetReferenceImportJob Operation public virtual GetReferenceImportJobResponse EndGetReferenceImportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetReferenceMetadata ///

/// Gets information about a genome reference's metadata. ///

/// Container for the necessary parameters to execute the GetReferenceMetadata service method. /// /// The response from the GetReferenceMetadata service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetReferenceMetadata Operation public virtual GetReferenceMetadataResponse GetReferenceMetadata(GetReferenceMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetReferenceMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReferenceMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetReferenceMetadata operation. ///

/// /// Container for the necessary parameters to execute the GetReferenceMetadata operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetReferenceMetadata /// operation. /// REST API Reference for GetReferenceMetadata Operation public virtual IAsyncResult BeginGetReferenceMetadata(GetReferenceMetadataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetReferenceMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReferenceMetadataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetReferenceMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginGetReferenceMetadata. /// /// Returns a GetReferenceMetadataResult from Omics. /// REST API Reference for GetReferenceMetadata Operation public virtual GetReferenceMetadataResponse EndGetReferenceMetadata(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetReferenceStore ///

/// Gets information about a reference store. ///

/// Container for the necessary parameters to execute the GetReferenceStore service method. /// /// The response from the GetReferenceStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetReferenceStore Operation public virtual GetReferenceStoreResponse GetReferenceStore(GetReferenceStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetReferenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReferenceStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetReferenceStore operation. ///

/// /// Container for the necessary parameters to execute the GetReferenceStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetReferenceStore /// operation. /// REST API Reference for GetReferenceStore Operation public virtual IAsyncResult BeginGetReferenceStore(GetReferenceStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetReferenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReferenceStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetReferenceStore operation. ///

/// /// The IAsyncResult returned by the call to BeginGetReferenceStore. /// /// Returns a GetReferenceStoreResult from Omics. /// REST API Reference for GetReferenceStore Operation public virtual GetReferenceStoreResponse EndGetReferenceStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRun ///

/// Gets information about a workflow run. ///

/// Container for the necessary parameters to execute the GetRun service method. /// /// The response from the GetRun service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetRun Operation public virtual GetRunResponse GetRun(GetRunRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRunRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRunResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRun operation. ///

/// /// Container for the necessary parameters to execute the GetRun operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRun /// operation. /// REST API Reference for GetRun Operation public virtual IAsyncResult BeginGetRun(GetRunRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRunRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRunResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRun operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRun. /// /// Returns a GetRunResult from Omics. /// REST API Reference for GetRun Operation public virtual GetRunResponse EndGetRun(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRunGroup ///

/// Gets information about a workflow run group. ///

/// Container for the necessary parameters to execute the GetRunGroup service method. /// /// The response from the GetRunGroup service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetRunGroup Operation public virtual GetRunGroupResponse GetRunGroup(GetRunGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRunGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRunGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRunGroup operation. ///

/// /// Container for the necessary parameters to execute the GetRunGroup operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRunGroup /// operation. /// REST API Reference for GetRunGroup Operation public virtual IAsyncResult BeginGetRunGroup(GetRunGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRunGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRunGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRunGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRunGroup. /// /// Returns a GetRunGroupResult from Omics. /// REST API Reference for GetRunGroup Operation public virtual GetRunGroupResponse EndGetRunGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRunTask ///

/// Gets information about a workflow run task. ///

/// Container for the necessary parameters to execute the GetRunTask service method. /// /// The response from the GetRunTask service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetRunTask Operation public virtual GetRunTaskResponse GetRunTask(GetRunTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRunTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRunTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetRunTask operation. ///

/// /// Container for the necessary parameters to execute the GetRunTask operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRunTask /// operation. /// REST API Reference for GetRunTask Operation public virtual IAsyncResult BeginGetRunTask(GetRunTaskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRunTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRunTaskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetRunTask operation. ///

/// /// The IAsyncResult returned by the call to BeginGetRunTask. /// /// Returns a GetRunTaskResult from Omics. /// REST API Reference for GetRunTask Operation public virtual GetRunTaskResponse EndGetRunTask(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetSequenceStore ///

/// Gets information about a sequence store. ///

/// Container for the necessary parameters to execute the GetSequenceStore service method. /// /// The response from the GetSequenceStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetSequenceStore Operation public virtual GetSequenceStoreResponse GetSequenceStore(GetSequenceStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSequenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSequenceStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetSequenceStore operation. ///

/// /// Container for the necessary parameters to execute the GetSequenceStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetSequenceStore /// operation. /// REST API Reference for GetSequenceStore Operation public virtual IAsyncResult BeginGetSequenceStore(GetSequenceStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetSequenceStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSequenceStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetSequenceStore operation. ///

/// /// The IAsyncResult returned by the call to BeginGetSequenceStore. /// /// Returns a GetSequenceStoreResult from Omics. /// REST API Reference for GetSequenceStore Operation public virtual GetSequenceStoreResponse EndGetSequenceStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetVariantImportJob ///

/// Gets information about a variant import job. ///

/// Container for the necessary parameters to execute the GetVariantImportJob service method. /// /// The response from the GetVariantImportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetVariantImportJob Operation public virtual GetVariantImportJobResponse GetVariantImportJob(GetVariantImportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetVariantImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetVariantImportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetVariantImportJob operation. ///

/// /// Container for the necessary parameters to execute the GetVariantImportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetVariantImportJob /// operation. /// REST API Reference for GetVariantImportJob Operation public virtual IAsyncResult BeginGetVariantImportJob(GetVariantImportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetVariantImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = GetVariantImportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetVariantImportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginGetVariantImportJob. /// /// Returns a GetVariantImportJobResult from Omics. /// REST API Reference for GetVariantImportJob Operation public virtual GetVariantImportJobResponse EndGetVariantImportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetVariantStore ///

/// Gets information about a variant store. ///

/// Container for the necessary parameters to execute the GetVariantStore service method. /// /// The response from the GetVariantStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetVariantStore Operation public virtual GetVariantStoreResponse GetVariantStore(GetVariantStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetVariantStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = GetVariantStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetVariantStore operation. ///

/// /// Container for the necessary parameters to execute the GetVariantStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetVariantStore /// operation. /// REST API Reference for GetVariantStore Operation public virtual IAsyncResult BeginGetVariantStore(GetVariantStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetVariantStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = GetVariantStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetVariantStore operation. ///

/// /// The IAsyncResult returned by the call to BeginGetVariantStore. /// /// Returns a GetVariantStoreResult from Omics. /// REST API Reference for GetVariantStore Operation public virtual GetVariantStoreResponse EndGetVariantStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetWorkflow ///

/// Gets information about a workflow. ///

/// Container for the necessary parameters to execute the GetWorkflow service method. /// /// The response from the GetWorkflow service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetWorkflow Operation public virtual GetWorkflowResponse GetWorkflow(GetWorkflowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkflowRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkflowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetWorkflow operation. ///

/// /// Container for the necessary parameters to execute the GetWorkflow operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetWorkflow /// operation. /// REST API Reference for GetWorkflow Operation public virtual IAsyncResult BeginGetWorkflow(GetWorkflowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkflowRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkflowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetWorkflow operation. ///

/// /// The IAsyncResult returned by the call to BeginGetWorkflow. /// /// Returns a GetWorkflowResult from Omics. /// REST API Reference for GetWorkflow Operation public virtual GetWorkflowResponse EndGetWorkflow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListAnnotationImportJobs ///

/// Retrieves a list of annotation import jobs. ///

/// Container for the necessary parameters to execute the ListAnnotationImportJobs service method. /// /// The response from the ListAnnotationImportJobs service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListAnnotationImportJobs Operation public virtual ListAnnotationImportJobsResponse ListAnnotationImportJobs(ListAnnotationImportJobsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAnnotationImportJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAnnotationImportJobsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListAnnotationImportJobs operation. ///

/// /// Container for the necessary parameters to execute the ListAnnotationImportJobs operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListAnnotationImportJobs /// operation. /// REST API Reference for ListAnnotationImportJobs Operation public virtual IAsyncResult BeginListAnnotationImportJobs(ListAnnotationImportJobsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListAnnotationImportJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAnnotationImportJobsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListAnnotationImportJobs operation. ///

/// /// The IAsyncResult returned by the call to BeginListAnnotationImportJobs. /// /// Returns a ListAnnotationImportJobsResult from Omics. /// REST API Reference for ListAnnotationImportJobs Operation public virtual ListAnnotationImportJobsResponse EndListAnnotationImportJobs(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListAnnotationStores ///

/// Retrieves a list of annotation stores. ///

/// Container for the necessary parameters to execute the ListAnnotationStores service method. /// /// The response from the ListAnnotationStores service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListAnnotationStores Operation public virtual ListAnnotationStoresResponse ListAnnotationStores(ListAnnotationStoresRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAnnotationStoresRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAnnotationStoresResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListAnnotationStores operation. ///

/// /// Container for the necessary parameters to execute the ListAnnotationStores operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListAnnotationStores /// operation. /// REST API Reference for ListAnnotationStores Operation public virtual IAsyncResult BeginListAnnotationStores(ListAnnotationStoresRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListAnnotationStoresRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAnnotationStoresResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListAnnotationStores operation. ///

/// /// The IAsyncResult returned by the call to BeginListAnnotationStores. /// /// Returns a ListAnnotationStoresResult from Omics. /// REST API Reference for ListAnnotationStores Operation public virtual ListAnnotationStoresResponse EndListAnnotationStores(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListMultipartReadSetUploads ///

/// Lists all multipart read set uploads and their statuses. ///

/// Container for the necessary parameters to execute the ListMultipartReadSetUploads service method. /// /// The response from the ListMultipartReadSetUploads service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The operation is not supported by Amazon Omics, or the API does not exist. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListMultipartReadSetUploads Operation public virtual ListMultipartReadSetUploadsResponse ListMultipartReadSetUploads(ListMultipartReadSetUploadsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListMultipartReadSetUploadsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListMultipartReadSetUploadsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListMultipartReadSetUploads operation. ///

/// /// Container for the necessary parameters to execute the ListMultipartReadSetUploads operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListMultipartReadSetUploads /// operation. /// REST API Reference for ListMultipartReadSetUploads Operation public virtual IAsyncResult BeginListMultipartReadSetUploads(ListMultipartReadSetUploadsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListMultipartReadSetUploadsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListMultipartReadSetUploadsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListMultipartReadSetUploads operation. ///

/// /// The IAsyncResult returned by the call to BeginListMultipartReadSetUploads. /// /// Returns a ListMultipartReadSetUploadsResult from Omics. /// REST API Reference for ListMultipartReadSetUploads Operation public virtual ListMultipartReadSetUploadsResponse EndListMultipartReadSetUploads(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReadSetActivationJobs ///

/// Retrieves a list of read set activation jobs. ///

/// Container for the necessary parameters to execute the ListReadSetActivationJobs service method. /// /// The response from the ListReadSetActivationJobs service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListReadSetActivationJobs Operation public virtual ListReadSetActivationJobsResponse ListReadSetActivationJobs(ListReadSetActivationJobsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReadSetActivationJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReadSetActivationJobsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListReadSetActivationJobs operation. ///

/// /// Container for the necessary parameters to execute the ListReadSetActivationJobs operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListReadSetActivationJobs /// operation. /// REST API Reference for ListReadSetActivationJobs Operation public virtual IAsyncResult BeginListReadSetActivationJobs(ListReadSetActivationJobsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReadSetActivationJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReadSetActivationJobsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListReadSetActivationJobs operation. ///

/// /// The IAsyncResult returned by the call to BeginListReadSetActivationJobs. /// /// Returns a ListReadSetActivationJobsResult from Omics. /// REST API Reference for ListReadSetActivationJobs Operation public virtual ListReadSetActivationJobsResponse EndListReadSetActivationJobs(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReadSetExportJobs ///

/// Retrieves a list of read set export jobs. ///

/// Container for the necessary parameters to execute the ListReadSetExportJobs service method. /// /// The response from the ListReadSetExportJobs service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListReadSetExportJobs Operation public virtual ListReadSetExportJobsResponse ListReadSetExportJobs(ListReadSetExportJobsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReadSetExportJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReadSetExportJobsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListReadSetExportJobs operation. ///

/// /// Container for the necessary parameters to execute the ListReadSetExportJobs operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListReadSetExportJobs /// operation. /// REST API Reference for ListReadSetExportJobs Operation public virtual IAsyncResult BeginListReadSetExportJobs(ListReadSetExportJobsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReadSetExportJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReadSetExportJobsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListReadSetExportJobs operation. ///

/// /// The IAsyncResult returned by the call to BeginListReadSetExportJobs. /// /// Returns a ListReadSetExportJobsResult from Omics. /// REST API Reference for ListReadSetExportJobs Operation public virtual ListReadSetExportJobsResponse EndListReadSetExportJobs(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReadSetImportJobs ///

/// Retrieves a list of read set import jobs. ///

/// Container for the necessary parameters to execute the ListReadSetImportJobs service method. /// /// The response from the ListReadSetImportJobs service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListReadSetImportJobs Operation public virtual ListReadSetImportJobsResponse ListReadSetImportJobs(ListReadSetImportJobsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReadSetImportJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReadSetImportJobsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListReadSetImportJobs operation. ///

/// /// Container for the necessary parameters to execute the ListReadSetImportJobs operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListReadSetImportJobs /// operation. /// REST API Reference for ListReadSetImportJobs Operation public virtual IAsyncResult BeginListReadSetImportJobs(ListReadSetImportJobsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReadSetImportJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReadSetImportJobsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListReadSetImportJobs operation. ///

/// /// The IAsyncResult returned by the call to BeginListReadSetImportJobs. /// /// Returns a ListReadSetImportJobsResult from Omics. /// REST API Reference for ListReadSetImportJobs Operation public virtual ListReadSetImportJobsResponse EndListReadSetImportJobs(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReadSets ///

/// Retrieves a list of read sets. ///

/// Container for the necessary parameters to execute the ListReadSets service method. /// /// The response from the ListReadSets service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListReadSets Operation public virtual ListReadSetsResponse ListReadSets(ListReadSetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReadSetsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReadSetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListReadSets operation. ///

/// /// Container for the necessary parameters to execute the ListReadSets operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListReadSets /// operation. /// REST API Reference for ListReadSets Operation public virtual IAsyncResult BeginListReadSets(ListReadSetsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReadSetsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReadSetsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListReadSets operation. ///

/// /// The IAsyncResult returned by the call to BeginListReadSets. /// /// Returns a ListReadSetsResult from Omics. /// REST API Reference for ListReadSets Operation public virtual ListReadSetsResponse EndListReadSets(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReadSetUploadParts ///

/// This operation will list all parts in a requested multipart upload for a sequence /// store. ///

/// Container for the necessary parameters to execute the ListReadSetUploadParts service method. /// /// The response from the ListReadSetUploadParts service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The operation is not supported by Amazon Omics, or the API does not exist. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListReadSetUploadParts Operation public virtual ListReadSetUploadPartsResponse ListReadSetUploadParts(ListReadSetUploadPartsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReadSetUploadPartsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReadSetUploadPartsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListReadSetUploadParts operation. ///

/// /// Container for the necessary parameters to execute the ListReadSetUploadParts operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListReadSetUploadParts /// operation. /// REST API Reference for ListReadSetUploadParts Operation public virtual IAsyncResult BeginListReadSetUploadParts(ListReadSetUploadPartsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReadSetUploadPartsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReadSetUploadPartsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListReadSetUploadParts operation. ///

/// /// The IAsyncResult returned by the call to BeginListReadSetUploadParts. /// /// Returns a ListReadSetUploadPartsResult from Omics. /// REST API Reference for ListReadSetUploadParts Operation public virtual ListReadSetUploadPartsResponse EndListReadSetUploadParts(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReferenceImportJobs ///

/// Retrieves a list of reference import jobs. ///

/// Container for the necessary parameters to execute the ListReferenceImportJobs service method. /// /// The response from the ListReferenceImportJobs service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListReferenceImportJobs Operation public virtual ListReferenceImportJobsResponse ListReferenceImportJobs(ListReferenceImportJobsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReferenceImportJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReferenceImportJobsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListReferenceImportJobs operation. ///

/// /// Container for the necessary parameters to execute the ListReferenceImportJobs operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListReferenceImportJobs /// operation. /// REST API Reference for ListReferenceImportJobs Operation public virtual IAsyncResult BeginListReferenceImportJobs(ListReferenceImportJobsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReferenceImportJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReferenceImportJobsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListReferenceImportJobs operation. ///

/// /// The IAsyncResult returned by the call to BeginListReferenceImportJobs. /// /// Returns a ListReferenceImportJobsResult from Omics. /// REST API Reference for ListReferenceImportJobs Operation public virtual ListReferenceImportJobsResponse EndListReferenceImportJobs(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReferences ///

/// Retrieves a list of references. ///

/// Container for the necessary parameters to execute the ListReferences service method. /// /// The response from the ListReferences service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListReferences Operation public virtual ListReferencesResponse ListReferences(ListReferencesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReferencesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReferencesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListReferences operation. ///

/// /// Container for the necessary parameters to execute the ListReferences operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListReferences /// operation. /// REST API Reference for ListReferences Operation public virtual IAsyncResult BeginListReferences(ListReferencesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReferencesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReferencesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListReferences operation. ///

/// /// The IAsyncResult returned by the call to BeginListReferences. /// /// Returns a ListReferencesResult from Omics. /// REST API Reference for ListReferences Operation public virtual ListReferencesResponse EndListReferences(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReferenceStores ///

/// Retrieves a list of reference stores. ///

/// Container for the necessary parameters to execute the ListReferenceStores service method. /// /// The response from the ListReferenceStores service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListReferenceStores Operation public virtual ListReferenceStoresResponse ListReferenceStores(ListReferenceStoresRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReferenceStoresRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReferenceStoresResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListReferenceStores operation. ///

/// /// Container for the necessary parameters to execute the ListReferenceStores operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListReferenceStores /// operation. /// REST API Reference for ListReferenceStores Operation public virtual IAsyncResult BeginListReferenceStores(ListReferenceStoresRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReferenceStoresRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReferenceStoresResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListReferenceStores operation. ///

/// /// The IAsyncResult returned by the call to BeginListReferenceStores. /// /// Returns a ListReferenceStoresResult from Omics. /// REST API Reference for ListReferenceStores Operation public virtual ListReferenceStoresResponse EndListReferenceStores(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListRunGroups ///

/// Retrieves a list of run groups. ///

/// Container for the necessary parameters to execute the ListRunGroups service method. /// /// The response from the ListRunGroups service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListRunGroups Operation public virtual ListRunGroupsResponse ListRunGroups(ListRunGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListRunGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRunGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListRunGroups operation. ///

/// /// Container for the necessary parameters to execute the ListRunGroups operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListRunGroups /// operation. /// REST API Reference for ListRunGroups Operation public virtual IAsyncResult BeginListRunGroups(ListRunGroupsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListRunGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRunGroupsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListRunGroups operation. ///

/// /// The IAsyncResult returned by the call to BeginListRunGroups. /// /// Returns a ListRunGroupsResult from Omics. /// REST API Reference for ListRunGroups Operation public virtual ListRunGroupsResponse EndListRunGroups(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListRuns ///

/// Retrieves a list of runs. ///

/// Container for the necessary parameters to execute the ListRuns service method. /// /// The response from the ListRuns service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListRuns Operation public virtual ListRunsResponse ListRuns(ListRunsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListRunsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRunsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListRuns operation. ///

/// /// Container for the necessary parameters to execute the ListRuns operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListRuns /// operation. /// REST API Reference for ListRuns Operation public virtual IAsyncResult BeginListRuns(ListRunsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListRunsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRunsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListRuns operation. ///

/// /// The IAsyncResult returned by the call to BeginListRuns. /// /// Returns a ListRunsResult from Omics. /// REST API Reference for ListRuns Operation public virtual ListRunsResponse EndListRuns(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListRunTasks ///

/// Retrieves a list of tasks for a run. ///

/// Container for the necessary parameters to execute the ListRunTasks service method. /// /// The response from the ListRunTasks service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListRunTasks Operation public virtual ListRunTasksResponse ListRunTasks(ListRunTasksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListRunTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRunTasksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListRunTasks operation. ///

/// /// Container for the necessary parameters to execute the ListRunTasks operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListRunTasks /// operation. /// REST API Reference for ListRunTasks Operation public virtual IAsyncResult BeginListRunTasks(ListRunTasksRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListRunTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRunTasksResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListRunTasks operation. ///

/// /// The IAsyncResult returned by the call to BeginListRunTasks. /// /// Returns a ListRunTasksResult from Omics. /// REST API Reference for ListRunTasks Operation public virtual ListRunTasksResponse EndListRunTasks(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListSequenceStores ///

/// Retrieves a list of sequence stores. ///

/// Container for the necessary parameters to execute the ListSequenceStores service method. /// /// The response from the ListSequenceStores service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListSequenceStores Operation public virtual ListSequenceStoresResponse ListSequenceStores(ListSequenceStoresRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListSequenceStoresRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSequenceStoresResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListSequenceStores operation. ///

/// /// Container for the necessary parameters to execute the ListSequenceStores operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListSequenceStores /// operation. /// REST API Reference for ListSequenceStores Operation public virtual IAsyncResult BeginListSequenceStores(ListSequenceStoresRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListSequenceStoresRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSequenceStoresResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListSequenceStores operation. ///

/// /// The IAsyncResult returned by the call to BeginListSequenceStores. /// /// Returns a ListSequenceStoresResult from Omics. /// REST API Reference for ListSequenceStores Operation public virtual ListSequenceStoresResponse EndListSequenceStores(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

/// Retrieves a list of tags for a resource. ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListTagsForResource operation. ///

/// /// Container for the necessary parameters to execute the ListTagsForResource operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTagsForResource /// operation. /// REST API Reference for ListTagsForResource Operation public virtual IAsyncResult BeginListTagsForResource(ListTagsForResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListTagsForResource operation. ///

/// /// The IAsyncResult returned by the call to BeginListTagsForResource. /// /// Returns a ListTagsForResourceResult from Omics. /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListVariantImportJobs ///

/// Retrieves a list of variant import jobs. ///

/// Container for the necessary parameters to execute the ListVariantImportJobs service method. /// /// The response from the ListVariantImportJobs service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListVariantImportJobs Operation public virtual ListVariantImportJobsResponse ListVariantImportJobs(ListVariantImportJobsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListVariantImportJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListVariantImportJobsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListVariantImportJobs operation. ///

/// /// Container for the necessary parameters to execute the ListVariantImportJobs operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListVariantImportJobs /// operation. /// REST API Reference for ListVariantImportJobs Operation public virtual IAsyncResult BeginListVariantImportJobs(ListVariantImportJobsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListVariantImportJobsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListVariantImportJobsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListVariantImportJobs operation. ///

/// /// The IAsyncResult returned by the call to BeginListVariantImportJobs. /// /// Returns a ListVariantImportJobsResult from Omics. /// REST API Reference for ListVariantImportJobs Operation public virtual ListVariantImportJobsResponse EndListVariantImportJobs(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListVariantStores ///

/// Retrieves a list of variant stores. ///

/// Container for the necessary parameters to execute the ListVariantStores service method. /// /// The response from the ListVariantStores service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListVariantStores Operation public virtual ListVariantStoresResponse ListVariantStores(ListVariantStoresRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListVariantStoresRequestMarshaller.Instance; options.ResponseUnmarshaller = ListVariantStoresResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListVariantStores operation. ///

/// /// Container for the necessary parameters to execute the ListVariantStores operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListVariantStores /// operation. /// REST API Reference for ListVariantStores Operation public virtual IAsyncResult BeginListVariantStores(ListVariantStoresRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListVariantStoresRequestMarshaller.Instance; options.ResponseUnmarshaller = ListVariantStoresResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListVariantStores operation. ///

/// /// The IAsyncResult returned by the call to BeginListVariantStores. /// /// Returns a ListVariantStoresResult from Omics. /// REST API Reference for ListVariantStores Operation public virtual ListVariantStoresResponse EndListVariantStores(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListWorkflows ///

/// Retrieves a list of workflows. ///

/// Container for the necessary parameters to execute the ListWorkflows service method. /// /// The response from the ListWorkflows service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListWorkflows Operation public virtual ListWorkflowsResponse ListWorkflows(ListWorkflowsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkflowsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkflowsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListWorkflows operation. ///

/// /// Container for the necessary parameters to execute the ListWorkflows operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListWorkflows /// operation. /// REST API Reference for ListWorkflows Operation public virtual IAsyncResult BeginListWorkflows(ListWorkflowsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkflowsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkflowsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListWorkflows operation. ///

/// /// The IAsyncResult returned by the call to BeginListWorkflows. /// /// Returns a ListWorkflowsResult from Omics. /// REST API Reference for ListWorkflows Operation public virtual ListWorkflowsResponse EndListWorkflows(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartAnnotationImportJob ///

/// Starts an annotation import job. ///

/// Container for the necessary parameters to execute the StartAnnotationImportJob service method. /// /// The response from the StartAnnotationImportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for StartAnnotationImportJob Operation public virtual StartAnnotationImportJobResponse StartAnnotationImportJob(StartAnnotationImportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartAnnotationImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartAnnotationImportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartAnnotationImportJob operation. ///

/// /// Container for the necessary parameters to execute the StartAnnotationImportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartAnnotationImportJob /// operation. /// REST API Reference for StartAnnotationImportJob Operation public virtual IAsyncResult BeginStartAnnotationImportJob(StartAnnotationImportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartAnnotationImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartAnnotationImportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartAnnotationImportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginStartAnnotationImportJob. /// /// Returns a StartAnnotationImportJobResult from Omics. /// REST API Reference for StartAnnotationImportJob Operation public virtual StartAnnotationImportJobResponse EndStartAnnotationImportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartReadSetActivationJob ///

/// Activates an archived read set. To reduce storage charges, Amazon Omics archives unused /// read sets after 30 days. ///

/// Container for the necessary parameters to execute the StartReadSetActivationJob service method. /// /// The response from the StartReadSetActivationJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for StartReadSetActivationJob Operation public virtual StartReadSetActivationJobResponse StartReadSetActivationJob(StartReadSetActivationJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartReadSetActivationJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartReadSetActivationJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartReadSetActivationJob operation. ///

/// /// Container for the necessary parameters to execute the StartReadSetActivationJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartReadSetActivationJob /// operation. /// REST API Reference for StartReadSetActivationJob Operation public virtual IAsyncResult BeginStartReadSetActivationJob(StartReadSetActivationJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartReadSetActivationJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartReadSetActivationJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartReadSetActivationJob operation. ///

/// /// The IAsyncResult returned by the call to BeginStartReadSetActivationJob. /// /// Returns a StartReadSetActivationJobResult from Omics. /// REST API Reference for StartReadSetActivationJob Operation public virtual StartReadSetActivationJobResponse EndStartReadSetActivationJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartReadSetExportJob ///

/// Exports a read set to Amazon S3. ///

/// Container for the necessary parameters to execute the StartReadSetExportJob service method. /// /// The response from the StartReadSetExportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for StartReadSetExportJob Operation public virtual StartReadSetExportJobResponse StartReadSetExportJob(StartReadSetExportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartReadSetExportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartReadSetExportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartReadSetExportJob operation. ///

/// /// Container for the necessary parameters to execute the StartReadSetExportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartReadSetExportJob /// operation. /// REST API Reference for StartReadSetExportJob Operation public virtual IAsyncResult BeginStartReadSetExportJob(StartReadSetExportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartReadSetExportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartReadSetExportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartReadSetExportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginStartReadSetExportJob. /// /// Returns a StartReadSetExportJobResult from Omics. /// REST API Reference for StartReadSetExportJob Operation public virtual StartReadSetExportJobResponse EndStartReadSetExportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartReadSetImportJob ///

/// Starts a read set import job. ///

/// Container for the necessary parameters to execute the StartReadSetImportJob service method. /// /// The response from the StartReadSetImportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for StartReadSetImportJob Operation public virtual StartReadSetImportJobResponse StartReadSetImportJob(StartReadSetImportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartReadSetImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartReadSetImportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartReadSetImportJob operation. ///

/// /// Container for the necessary parameters to execute the StartReadSetImportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartReadSetImportJob /// operation. /// REST API Reference for StartReadSetImportJob Operation public virtual IAsyncResult BeginStartReadSetImportJob(StartReadSetImportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartReadSetImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartReadSetImportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartReadSetImportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginStartReadSetImportJob. /// /// Returns a StartReadSetImportJobResult from Omics. /// REST API Reference for StartReadSetImportJob Operation public virtual StartReadSetImportJobResponse EndStartReadSetImportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartReferenceImportJob ///

/// Starts a reference import job. ///

/// Container for the necessary parameters to execute the StartReferenceImportJob service method. /// /// The response from the StartReferenceImportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for StartReferenceImportJob Operation public virtual StartReferenceImportJobResponse StartReferenceImportJob(StartReferenceImportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartReferenceImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartReferenceImportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartReferenceImportJob operation. ///

/// /// Container for the necessary parameters to execute the StartReferenceImportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartReferenceImportJob /// operation. /// REST API Reference for StartReferenceImportJob Operation public virtual IAsyncResult BeginStartReferenceImportJob(StartReferenceImportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartReferenceImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartReferenceImportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartReferenceImportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginStartReferenceImportJob. /// /// Returns a StartReferenceImportJobResult from Omics. /// REST API Reference for StartReferenceImportJob Operation public virtual StartReferenceImportJobResponse EndStartReferenceImportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartRun ///

/// Starts a run. ///

/// Container for the necessary parameters to execute the StartRun service method. /// /// The response from the StartRun service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for StartRun Operation public virtual StartRunResponse StartRun(StartRunRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartRunRequestMarshaller.Instance; options.ResponseUnmarshaller = StartRunResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartRun operation. ///

/// /// Container for the necessary parameters to execute the StartRun operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartRun /// operation. /// REST API Reference for StartRun Operation public virtual IAsyncResult BeginStartRun(StartRunRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartRunRequestMarshaller.Instance; options.ResponseUnmarshaller = StartRunResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartRun operation. ///

/// /// The IAsyncResult returned by the call to BeginStartRun. /// /// Returns a StartRunResult from Omics. /// REST API Reference for StartRun Operation public virtual StartRunResponse EndStartRun(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartVariantImportJob ///

/// Starts a variant import job. ///

/// Container for the necessary parameters to execute the StartVariantImportJob service method. /// /// The response from the StartVariantImportJob service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for StartVariantImportJob Operation public virtual StartVariantImportJobResponse StartVariantImportJob(StartVariantImportJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartVariantImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartVariantImportJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartVariantImportJob operation. ///

/// /// Container for the necessary parameters to execute the StartVariantImportJob operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartVariantImportJob /// operation. /// REST API Reference for StartVariantImportJob Operation public virtual IAsyncResult BeginStartVariantImportJob(StartVariantImportJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartVariantImportJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartVariantImportJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartVariantImportJob operation. ///

/// /// The IAsyncResult returned by the call to BeginStartVariantImportJob. /// /// Returns a StartVariantImportJobResult from Omics. /// REST API Reference for StartVariantImportJob Operation public virtual StartVariantImportJobResponse EndStartVariantImportJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource ///

/// Tags a resource. ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for TagResource Operation public virtual TagResourceResponse TagResource(TagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the TagResource operation. ///

/// /// Container for the necessary parameters to execute the TagResource operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTagResource /// operation. /// REST API Reference for TagResource Operation public virtual IAsyncResult BeginTagResource(TagResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the TagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginTagResource. /// /// Returns a TagResourceResult from Omics. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource ///

/// Removes tags from a resource. ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse UntagResource(UntagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UntagResource operation. ///

/// /// Container for the necessary parameters to execute the UntagResource operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUntagResource /// operation. /// REST API Reference for UntagResource Operation public virtual IAsyncResult BeginUntagResource(UntagResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UntagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginUntagResource. /// /// Returns a UntagResourceResult from Omics. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateAnnotationStore ///

/// Updates an annotation store. ///

/// Container for the necessary parameters to execute the UpdateAnnotationStore service method. /// /// The response from the UpdateAnnotationStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateAnnotationStore Operation public virtual UpdateAnnotationStoreResponse UpdateAnnotationStore(UpdateAnnotationStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAnnotationStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAnnotationStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateAnnotationStore operation. ///

/// /// Container for the necessary parameters to execute the UpdateAnnotationStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateAnnotationStore /// operation. /// REST API Reference for UpdateAnnotationStore Operation public virtual IAsyncResult BeginUpdateAnnotationStore(UpdateAnnotationStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAnnotationStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAnnotationStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateAnnotationStore operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateAnnotationStore. /// /// Returns a UpdateAnnotationStoreResult from Omics. /// REST API Reference for UpdateAnnotationStore Operation public virtual UpdateAnnotationStoreResponse EndUpdateAnnotationStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateRunGroup ///

/// Updates a run group. ///

/// Container for the necessary parameters to execute the UpdateRunGroup service method. /// /// The response from the UpdateRunGroup service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateRunGroup Operation public virtual UpdateRunGroupResponse UpdateRunGroup(UpdateRunGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRunGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRunGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateRunGroup operation. ///

/// /// Container for the necessary parameters to execute the UpdateRunGroup operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateRunGroup /// operation. /// REST API Reference for UpdateRunGroup Operation public virtual IAsyncResult BeginUpdateRunGroup(UpdateRunGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRunGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRunGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateRunGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateRunGroup. /// /// Returns a UpdateRunGroupResult from Omics. /// REST API Reference for UpdateRunGroup Operation public virtual UpdateRunGroupResponse EndUpdateRunGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateVariantStore ///

/// Updates a variant store. ///

/// Container for the necessary parameters to execute the UpdateVariantStore service method. /// /// The response from the UpdateVariantStore service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The target resource was not found in the current Region. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateVariantStore Operation public virtual UpdateVariantStoreResponse UpdateVariantStore(UpdateVariantStoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateVariantStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateVariantStoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateVariantStore operation. ///

/// /// Container for the necessary parameters to execute the UpdateVariantStore operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateVariantStore /// operation. /// REST API Reference for UpdateVariantStore Operation public virtual IAsyncResult BeginUpdateVariantStore(UpdateVariantStoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateVariantStoreRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateVariantStoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateVariantStore operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateVariantStore. /// /// Returns a UpdateVariantStoreResult from Omics. /// REST API Reference for UpdateVariantStore Operation public virtual UpdateVariantStoreResponse EndUpdateVariantStore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateWorkflow ///

/// Updates a workflow. ///

/// Container for the necessary parameters to execute the UpdateWorkflow service method. /// /// The response from the UpdateWorkflow service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// The request cannot be applied to the target resource in its current state. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateWorkflow Operation public virtual UpdateWorkflowResponse UpdateWorkflow(UpdateWorkflowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateWorkflowRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateWorkflowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateWorkflow operation. ///

/// /// Container for the necessary parameters to execute the UpdateWorkflow operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateWorkflow /// operation. /// REST API Reference for UpdateWorkflow Operation public virtual IAsyncResult BeginUpdateWorkflow(UpdateWorkflowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateWorkflowRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateWorkflowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateWorkflow operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateWorkflow. /// /// Returns a UpdateWorkflowResult from Omics. /// REST API Reference for UpdateWorkflow Operation public virtual UpdateWorkflowResponse EndUpdateWorkflow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UploadReadSetPart ///

/// This operation uploads a specific part of a read set. If you upload a new part using /// a previously used part number, the previously uploaded part will be overwritten. ///

/// Container for the necessary parameters to execute the UploadReadSetPart service method. /// /// The response from the UploadReadSetPart service method, as returned by Omics. /// /// You do not have sufficient access to perform this action. /// /// /// An unexpected error occurred. Try the request again. /// /// /// The operation is not supported by Amazon Omics, or the API does not exist. /// /// /// The request timed out. /// /// /// The target resource was not found in the current Region. /// /// /// The request exceeds a service quota. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UploadReadSetPart Operation public virtual UploadReadSetPartResponse UploadReadSetPart(UploadReadSetPartRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UploadReadSetPartRequestMarshaller.Instance; options.ResponseUnmarshaller = UploadReadSetPartResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UploadReadSetPart operation. ///

/// /// Container for the necessary parameters to execute the UploadReadSetPart operation on AmazonOmicsClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUploadReadSetPart /// operation. /// REST API Reference for UploadReadSetPart Operation public virtual IAsyncResult BeginUploadReadSetPart(UploadReadSetPartRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UploadReadSetPartRequestMarshaller.Instance; options.ResponseUnmarshaller = UploadReadSetPartResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UploadReadSetPart operation. ///

/// /// The IAsyncResult returned by the call to BeginUploadReadSetPart. /// /// Returns a UploadReadSetPartResult from Omics. /// REST API Reference for UploadReadSetPart Operation public virtual UploadReadSetPartResponse EndUploadReadSetPart(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }