/* * 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 m2-2021-04-28.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.MainframeModernization.Model; using Amazon.MainframeModernization.Model.Internal.MarshallTransformations; using Amazon.MainframeModernization.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.MainframeModernization { ///

/// Implementation for accessing MainframeModernization /// /// Amazon Web Services Mainframe Modernization provides tools and resources to help you /// plan and implement migration and modernization from mainframes to Amazon Web Services /// managed runtime environments. It provides tools for analyzing existing mainframe applications, /// developing or updating mainframe applications using COBOL or PL/I, and implementing /// an automated pipeline for continuous integration and continuous delivery (CI/CD) of /// the applications. ///

public partial class AmazonMainframeModernizationClient : AmazonServiceClient, IAmazonMainframeModernization { private static IServiceMetadata serviceMetadata = new AmazonMainframeModernizationMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private IMainframeModernizationPaginatorFactory _paginators; ///

/// Paginators for the service ///

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

/// Constructs AmazonMainframeModernizationClient 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 AmazonMainframeModernizationClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonMainframeModernizationConfig()) { } ///


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

/// ///

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


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

/// ///

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

/// Constructs AmazonMainframeModernizationClient with AWS Credentials ///

/// AWS Credentials public AmazonMainframeModernizationClient(AWSCredentials credentials) : this(credentials, new AmazonMainframeModernizationConfig()) { } ///

/// Constructs AmazonMainframeModernizationClient with AWS Credentials ///

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

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

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

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

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

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

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

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

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

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

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

/// Constructs AmazonMainframeModernizationClient 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 AmazonMainframeModernizationClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonMainframeModernizationConfig{RegionEndpoint = region}) { } ///

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

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonMainframeModernizationClient Configuration Object public AmazonMainframeModernizationClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonMainframeModernizationConfig 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 AmazonMainframeModernizationEndpointResolver()); } ///

/// 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 CancelBatchJobExecution ///

/// Cancels the running of a specific batch job execution. ///

/// Container for the necessary parameters to execute the CancelBatchJobExecution service method. /// /// The response from the CancelBatchJobExecution service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for CancelBatchJobExecution Operation public virtual CancelBatchJobExecutionResponse CancelBatchJobExecution(CancelBatchJobExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelBatchJobExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelBatchJobExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CancelBatchJobExecution operation on AmazonMainframeModernizationClient. /// 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 EndCancelBatchJobExecution /// operation. /// REST API Reference for CancelBatchJobExecution Operation public virtual IAsyncResult BeginCancelBatchJobExecution(CancelBatchJobExecutionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CancelBatchJobExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelBatchJobExecutionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCancelBatchJobExecution. /// /// Returns a CancelBatchJobExecutionResult from MainframeModernization. /// REST API Reference for CancelBatchJobExecution Operation public virtual CancelBatchJobExecutionResponse EndCancelBatchJobExecution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateApplication ///

/// Creates a new application with given parameters. Requires an existing runtime environment /// and application definition file. ///

/// Container for the necessary parameters to execute the CreateApplication service method. /// /// The response from the CreateApplication service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// One or more quotas for Amazon Web Services Mainframe Modernization exceeds the limit. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for CreateApplication Operation public virtual CreateApplicationResponse CreateApplication(CreateApplicationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateApplicationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateApplication operation on AmazonMainframeModernizationClient. /// 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 EndCreateApplication /// operation. /// REST API Reference for CreateApplication Operation public virtual IAsyncResult BeginCreateApplication(CreateApplicationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateApplicationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateApplication. /// /// Returns a CreateApplicationResult from MainframeModernization. /// REST API Reference for CreateApplication Operation public virtual CreateApplicationResponse EndCreateApplication(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDataSetImportTask ///

/// Starts a data set import task for a specific application. ///

/// Container for the necessary parameters to execute the CreateDataSetImportTask service method. /// /// The response from the CreateDataSetImportTask service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// One or more quotas for Amazon Web Services Mainframe Modernization exceeds the limit. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for CreateDataSetImportTask Operation public virtual CreateDataSetImportTaskResponse CreateDataSetImportTask(CreateDataSetImportTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDataSetImportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDataSetImportTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateDataSetImportTask operation on AmazonMainframeModernizationClient. /// 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 EndCreateDataSetImportTask /// operation. /// REST API Reference for CreateDataSetImportTask Operation public virtual IAsyncResult BeginCreateDataSetImportTask(CreateDataSetImportTaskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDataSetImportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDataSetImportTaskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateDataSetImportTask. /// /// Returns a CreateDataSetImportTaskResult from MainframeModernization. /// REST API Reference for CreateDataSetImportTask Operation public virtual CreateDataSetImportTaskResponse EndCreateDataSetImportTask(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDeployment ///

/// Creates and starts a deployment to deploy an application into a runtime environment. ///

/// Container for the necessary parameters to execute the CreateDeployment service method. /// /// The response from the CreateDeployment service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// One or more quotas for Amazon Web Services Mainframe Modernization exceeds the limit. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for CreateDeployment Operation public virtual CreateDeploymentResponse CreateDeployment(CreateDeploymentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDeploymentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateDeployment operation on AmazonMainframeModernizationClient. /// 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 EndCreateDeployment /// operation. /// REST API Reference for CreateDeployment Operation public virtual IAsyncResult BeginCreateDeployment(CreateDeploymentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDeploymentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateDeployment. /// /// Returns a CreateDeploymentResult from MainframeModernization. /// REST API Reference for CreateDeployment Operation public virtual CreateDeploymentResponse EndCreateDeployment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateEnvironment ///

/// Creates a runtime environment for a given runtime engine. ///

/// Container for the necessary parameters to execute the CreateEnvironment service method. /// /// The response from the CreateEnvironment service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// One or more quotas for Amazon Web Services Mainframe Modernization exceeds the limit. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for CreateEnvironment Operation public virtual CreateEnvironmentResponse CreateEnvironment(CreateEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateEnvironment operation on AmazonMainframeModernizationClient. /// 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 EndCreateEnvironment /// operation. /// REST API Reference for CreateEnvironment Operation public virtual IAsyncResult BeginCreateEnvironment(CreateEnvironmentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEnvironmentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateEnvironment. /// /// Returns a CreateEnvironmentResult from MainframeModernization. /// REST API Reference for CreateEnvironment Operation public virtual CreateEnvironmentResponse EndCreateEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteApplication ///

/// Deletes a specific application. You cannot delete a running application. ///

/// Container for the necessary parameters to execute the DeleteApplication service method. /// /// The response from the DeleteApplication service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for DeleteApplication Operation public virtual DeleteApplicationResponse DeleteApplication(DeleteApplicationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteApplicationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteApplication operation on AmazonMainframeModernizationClient. /// 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 EndDeleteApplication /// operation. /// REST API Reference for DeleteApplication Operation public virtual IAsyncResult BeginDeleteApplication(DeleteApplicationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteApplicationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteApplication. /// /// Returns a DeleteApplicationResult from MainframeModernization. /// REST API Reference for DeleteApplication Operation public virtual DeleteApplicationResponse EndDeleteApplication(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteApplicationFromEnvironment ///

/// Deletes a specific application from the specific runtime environment where it was /// previously deployed. You cannot delete a runtime environment using DeleteEnvironment /// if any application has ever been deployed to it. This API removes the association /// of the application with the runtime environment so you can delete the environment /// smoothly. ///

/// Container for the necessary parameters to execute the DeleteApplicationFromEnvironment service method. /// /// The response from the DeleteApplicationFromEnvironment service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for DeleteApplicationFromEnvironment Operation public virtual DeleteApplicationFromEnvironmentResponse DeleteApplicationFromEnvironment(DeleteApplicationFromEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteApplicationFromEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteApplicationFromEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteApplicationFromEnvironment operation on AmazonMainframeModernizationClient. /// 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 EndDeleteApplicationFromEnvironment /// operation. /// REST API Reference for DeleteApplicationFromEnvironment Operation public virtual IAsyncResult BeginDeleteApplicationFromEnvironment(DeleteApplicationFromEnvironmentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteApplicationFromEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteApplicationFromEnvironmentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteApplicationFromEnvironment. /// /// Returns a DeleteApplicationFromEnvironmentResult from MainframeModernization. /// REST API Reference for DeleteApplicationFromEnvironment Operation public virtual DeleteApplicationFromEnvironmentResponse EndDeleteApplicationFromEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteEnvironment ///

/// Deletes a specific runtime environment. The environment cannot contain deployed applications. /// If it does, you must delete those applications before you delete the environment. ///

/// Container for the necessary parameters to execute the DeleteEnvironment service method. /// /// The response from the DeleteEnvironment service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for DeleteEnvironment Operation public virtual DeleteEnvironmentResponse DeleteEnvironment(DeleteEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteEnvironment operation on AmazonMainframeModernizationClient. /// 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 EndDeleteEnvironment /// operation. /// REST API Reference for DeleteEnvironment Operation public virtual IAsyncResult BeginDeleteEnvironment(DeleteEnvironmentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEnvironmentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteEnvironment. /// /// Returns a DeleteEnvironmentResult from MainframeModernization. /// REST API Reference for DeleteEnvironment Operation public virtual DeleteEnvironmentResponse EndDeleteEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetApplication ///

/// Describes the details of a specific application. ///

/// Container for the necessary parameters to execute the GetApplication service method. /// /// The response from the GetApplication service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for GetApplication Operation public virtual GetApplicationResponse GetApplication(GetApplicationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetApplicationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetApplication operation on AmazonMainframeModernizationClient. /// 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 EndGetApplication /// operation. /// REST API Reference for GetApplication Operation public virtual IAsyncResult BeginGetApplication(GetApplicationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetApplicationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetApplication. /// /// Returns a GetApplicationResult from MainframeModernization. /// REST API Reference for GetApplication Operation public virtual GetApplicationResponse EndGetApplication(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetApplicationVersion ///

/// Returns details about a specific version of a specific application. ///

/// Container for the necessary parameters to execute the GetApplicationVersion service method. /// /// The response from the GetApplicationVersion service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for GetApplicationVersion Operation public virtual GetApplicationVersionResponse GetApplicationVersion(GetApplicationVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetApplicationVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetApplicationVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetApplicationVersion operation on AmazonMainframeModernizationClient. /// 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 EndGetApplicationVersion /// operation. /// REST API Reference for GetApplicationVersion Operation public virtual IAsyncResult BeginGetApplicationVersion(GetApplicationVersionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetApplicationVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetApplicationVersionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetApplicationVersion. /// /// Returns a GetApplicationVersionResult from MainframeModernization. /// REST API Reference for GetApplicationVersion Operation public virtual GetApplicationVersionResponse EndGetApplicationVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetBatchJobExecution ///

/// Gets the details of a specific batch job execution for a specific application. ///

/// Container for the necessary parameters to execute the GetBatchJobExecution service method. /// /// The response from the GetBatchJobExecution service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for GetBatchJobExecution Operation public virtual GetBatchJobExecutionResponse GetBatchJobExecution(GetBatchJobExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetBatchJobExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBatchJobExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetBatchJobExecution operation on AmazonMainframeModernizationClient. /// 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 EndGetBatchJobExecution /// operation. /// REST API Reference for GetBatchJobExecution Operation public virtual IAsyncResult BeginGetBatchJobExecution(GetBatchJobExecutionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetBatchJobExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBatchJobExecutionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetBatchJobExecution. /// /// Returns a GetBatchJobExecutionResult from MainframeModernization. /// REST API Reference for GetBatchJobExecution Operation public virtual GetBatchJobExecutionResponse EndGetBatchJobExecution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDataSetDetails ///

/// Gets the details of a specific data set. ///

/// Container for the necessary parameters to execute the GetDataSetDetails service method. /// /// The response from the GetDataSetDetails service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for GetDataSetDetails Operation public virtual GetDataSetDetailsResponse GetDataSetDetails(GetDataSetDetailsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataSetDetailsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataSetDetailsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetDataSetDetails operation on AmazonMainframeModernizationClient. /// 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 EndGetDataSetDetails /// operation. /// REST API Reference for GetDataSetDetails Operation public virtual IAsyncResult BeginGetDataSetDetails(GetDataSetDetailsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataSetDetailsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataSetDetailsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetDataSetDetails. /// /// Returns a GetDataSetDetailsResult from MainframeModernization. /// REST API Reference for GetDataSetDetails Operation public virtual GetDataSetDetailsResponse EndGetDataSetDetails(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDataSetImportTask ///

/// Gets the status of a data set import task initiated with the CreateDataSetImportTask /// operation. ///

/// Container for the necessary parameters to execute the GetDataSetImportTask service method. /// /// The response from the GetDataSetImportTask service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for GetDataSetImportTask Operation public virtual GetDataSetImportTaskResponse GetDataSetImportTask(GetDataSetImportTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataSetImportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataSetImportTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetDataSetImportTask operation on AmazonMainframeModernizationClient. /// 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 EndGetDataSetImportTask /// operation. /// REST API Reference for GetDataSetImportTask Operation public virtual IAsyncResult BeginGetDataSetImportTask(GetDataSetImportTaskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataSetImportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataSetImportTaskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetDataSetImportTask. /// /// Returns a GetDataSetImportTaskResult from MainframeModernization. /// REST API Reference for GetDataSetImportTask Operation public virtual GetDataSetImportTaskResponse EndGetDataSetImportTask(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDeployment ///

/// Gets details of a specific deployment with a given deployment identifier. ///

/// Container for the necessary parameters to execute the GetDeployment service method. /// /// The response from the GetDeployment service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for GetDeployment Operation public virtual GetDeploymentResponse GetDeployment(GetDeploymentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDeploymentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetDeployment operation on AmazonMainframeModernizationClient. /// 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 EndGetDeployment /// operation. /// REST API Reference for GetDeployment Operation public virtual IAsyncResult BeginGetDeployment(GetDeploymentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDeploymentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDeploymentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetDeployment. /// /// Returns a GetDeploymentResult from MainframeModernization. /// REST API Reference for GetDeployment Operation public virtual GetDeploymentResponse EndGetDeployment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetEnvironment ///

/// Describes a specific runtime environment. ///

/// Container for the necessary parameters to execute the GetEnvironment service method. /// /// The response from the GetEnvironment service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for GetEnvironment Operation public virtual GetEnvironmentResponse GetEnvironment(GetEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetEnvironment operation on AmazonMainframeModernizationClient. /// 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 EndGetEnvironment /// operation. /// REST API Reference for GetEnvironment Operation public virtual IAsyncResult BeginGetEnvironment(GetEnvironmentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetEnvironmentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetEnvironment. /// /// Returns a GetEnvironmentResult from MainframeModernization. /// REST API Reference for GetEnvironment Operation public virtual GetEnvironmentResponse EndGetEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetSignedBluinsightsUrl ///

/// Gets a single sign-on URL that can be used to connect to AWS Blu Insights. ///

/// Container for the necessary parameters to execute the GetSignedBluinsightsUrl service method. /// /// The response from the GetSignedBluinsightsUrl service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The number of requests made exceeds the limit. /// /// REST API Reference for GetSignedBluinsightsUrl Operation public virtual GetSignedBluinsightsUrlResponse GetSignedBluinsightsUrl(GetSignedBluinsightsUrlRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSignedBluinsightsUrlRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSignedBluinsightsUrlResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetSignedBluinsightsUrl operation on AmazonMainframeModernizationClient. /// 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 EndGetSignedBluinsightsUrl /// operation. /// REST API Reference for GetSignedBluinsightsUrl Operation public virtual IAsyncResult BeginGetSignedBluinsightsUrl(GetSignedBluinsightsUrlRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetSignedBluinsightsUrlRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSignedBluinsightsUrlResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetSignedBluinsightsUrl. /// /// Returns a GetSignedBluinsightsUrlResult from MainframeModernization. /// REST API Reference for GetSignedBluinsightsUrl Operation public virtual GetSignedBluinsightsUrlResponse EndGetSignedBluinsightsUrl(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListApplications ///

/// Lists the applications associated with a specific Amazon Web Services account. You /// can provide the unique identifier of a specific runtime environment in a query parameter /// to see all applications associated with that environment. ///

/// Container for the necessary parameters to execute the ListApplications service method. /// /// The response from the ListApplications service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for ListApplications Operation public virtual ListApplicationsResponse ListApplications(ListApplicationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListApplicationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListApplicationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListApplications operation on AmazonMainframeModernizationClient. /// 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 EndListApplications /// operation. /// REST API Reference for ListApplications Operation public virtual IAsyncResult BeginListApplications(ListApplicationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListApplicationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListApplicationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListApplications. /// /// Returns a ListApplicationsResult from MainframeModernization. /// REST API Reference for ListApplications Operation public virtual ListApplicationsResponse EndListApplications(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListApplicationVersions ///

/// Returns a list of the application versions for a specific application. ///

/// Container for the necessary parameters to execute the ListApplicationVersions service method. /// /// The response from the ListApplicationVersions service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for ListApplicationVersions Operation public virtual ListApplicationVersionsResponse ListApplicationVersions(ListApplicationVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListApplicationVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListApplicationVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListApplicationVersions operation on AmazonMainframeModernizationClient. /// 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 EndListApplicationVersions /// operation. /// REST API Reference for ListApplicationVersions Operation public virtual IAsyncResult BeginListApplicationVersions(ListApplicationVersionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListApplicationVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListApplicationVersionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListApplicationVersions. /// /// Returns a ListApplicationVersionsResult from MainframeModernization. /// REST API Reference for ListApplicationVersions Operation public virtual ListApplicationVersionsResponse EndListApplicationVersions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListBatchJobDefinitions ///

/// Lists all the available batch job definitions based on the batch job resources uploaded /// during the application creation. You can use the batch job definitions in the list /// to start a batch job. ///

/// Container for the necessary parameters to execute the ListBatchJobDefinitions service method. /// /// The response from the ListBatchJobDefinitions service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for ListBatchJobDefinitions Operation public virtual ListBatchJobDefinitionsResponse ListBatchJobDefinitions(ListBatchJobDefinitionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListBatchJobDefinitionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListBatchJobDefinitionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListBatchJobDefinitions operation on AmazonMainframeModernizationClient. /// 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 EndListBatchJobDefinitions /// operation. /// REST API Reference for ListBatchJobDefinitions Operation public virtual IAsyncResult BeginListBatchJobDefinitions(ListBatchJobDefinitionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListBatchJobDefinitionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListBatchJobDefinitionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListBatchJobDefinitions. /// /// Returns a ListBatchJobDefinitionsResult from MainframeModernization. /// REST API Reference for ListBatchJobDefinitions Operation public virtual ListBatchJobDefinitionsResponse EndListBatchJobDefinitions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListBatchJobExecutions ///

/// Lists historical, current, and scheduled batch job executions for a specific application. ///

/// Container for the necessary parameters to execute the ListBatchJobExecutions service method. /// /// The response from the ListBatchJobExecutions service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for ListBatchJobExecutions Operation public virtual ListBatchJobExecutionsResponse ListBatchJobExecutions(ListBatchJobExecutionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListBatchJobExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListBatchJobExecutionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListBatchJobExecutions operation on AmazonMainframeModernizationClient. /// 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 EndListBatchJobExecutions /// operation. /// REST API Reference for ListBatchJobExecutions Operation public virtual IAsyncResult BeginListBatchJobExecutions(ListBatchJobExecutionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListBatchJobExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListBatchJobExecutionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListBatchJobExecutions. /// /// Returns a ListBatchJobExecutionsResult from MainframeModernization. /// REST API Reference for ListBatchJobExecutions Operation public virtual ListBatchJobExecutionsResponse EndListBatchJobExecutions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListDataSetImportHistory ///

/// Lists the data set imports for the specified application. ///

/// Container for the necessary parameters to execute the ListDataSetImportHistory service method. /// /// The response from the ListDataSetImportHistory service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for ListDataSetImportHistory Operation public virtual ListDataSetImportHistoryResponse ListDataSetImportHistory(ListDataSetImportHistoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDataSetImportHistoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDataSetImportHistoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListDataSetImportHistory operation on AmazonMainframeModernizationClient. /// 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 EndListDataSetImportHistory /// operation. /// REST API Reference for ListDataSetImportHistory Operation public virtual IAsyncResult BeginListDataSetImportHistory(ListDataSetImportHistoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListDataSetImportHistoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDataSetImportHistoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListDataSetImportHistory. /// /// Returns a ListDataSetImportHistoryResult from MainframeModernization. /// REST API Reference for ListDataSetImportHistory Operation public virtual ListDataSetImportHistoryResponse EndListDataSetImportHistory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListDataSets ///

/// Lists the data sets imported for a specific application. In Amazon Web Services Mainframe /// Modernization, data sets are associated with applications deployed on runtime environments. /// This is known as importing data sets. Currently, Amazon Web Services Mainframe Modernization /// can import data sets into catalogs using CreateDataSetImportTask. ///

/// Container for the necessary parameters to execute the ListDataSets service method. /// /// The response from the ListDataSets service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for ListDataSets Operation public virtual ListDataSetsResponse ListDataSets(ListDataSetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDataSetsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDataSetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListDataSets operation on AmazonMainframeModernizationClient. /// 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 EndListDataSets /// operation. /// REST API Reference for ListDataSets Operation public virtual IAsyncResult BeginListDataSets(ListDataSetsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListDataSetsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDataSetsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListDataSets. /// /// Returns a ListDataSetsResult from MainframeModernization. /// REST API Reference for ListDataSets Operation public virtual ListDataSetsResponse EndListDataSets(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListDeployments ///

/// Returns a list of all deployments of a specific application. A deployment is a combination /// of a specific application and a specific version of that application. Each deployment /// is mapped to a particular application version. ///

/// Container for the necessary parameters to execute the ListDeployments service method. /// /// The response from the ListDeployments service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for ListDeployments Operation public virtual ListDeploymentsResponse ListDeployments(ListDeploymentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDeploymentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDeploymentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListDeployments operation on AmazonMainframeModernizationClient. /// 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 EndListDeployments /// operation. /// REST API Reference for ListDeployments Operation public virtual IAsyncResult BeginListDeployments(ListDeploymentsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListDeploymentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDeploymentsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListDeployments. /// /// Returns a ListDeploymentsResult from MainframeModernization. /// REST API Reference for ListDeployments Operation public virtual ListDeploymentsResponse EndListDeployments(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListEngineVersions ///

/// Lists the available engine versions. ///

/// Container for the necessary parameters to execute the ListEngineVersions service method. /// /// The response from the ListEngineVersions service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for ListEngineVersions Operation public virtual ListEngineVersionsResponse ListEngineVersions(ListEngineVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListEngineVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListEngineVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListEngineVersions operation on AmazonMainframeModernizationClient. /// 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 EndListEngineVersions /// operation. /// REST API Reference for ListEngineVersions Operation public virtual IAsyncResult BeginListEngineVersions(ListEngineVersionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListEngineVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListEngineVersionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListEngineVersions. /// /// Returns a ListEngineVersionsResult from MainframeModernization. /// REST API Reference for ListEngineVersions Operation public virtual ListEngineVersionsResponse EndListEngineVersions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListEnvironments ///

/// Lists the runtime environments. ///

/// Container for the necessary parameters to execute the ListEnvironments service method. /// /// The response from the ListEnvironments service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for ListEnvironments Operation public virtual ListEnvironmentsResponse ListEnvironments(ListEnvironmentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListEnvironmentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListEnvironmentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListEnvironments operation on AmazonMainframeModernizationClient. /// 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 EndListEnvironments /// operation. /// REST API Reference for ListEnvironments Operation public virtual IAsyncResult BeginListEnvironments(ListEnvironmentsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListEnvironmentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListEnvironmentsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListEnvironments. /// /// Returns a ListEnvironmentsResult from MainframeModernization. /// REST API Reference for ListEnvironments Operation public virtual ListEnvironmentsResponse EndListEnvironments(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

/// Lists the tags for the specified resource. ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// 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 AmazonMainframeModernizationClient. /// 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 MainframeModernization. /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartApplication ///

/// Starts an application that is currently stopped. ///

/// Container for the necessary parameters to execute the StartApplication service method. /// /// The response from the StartApplication service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for StartApplication Operation public virtual StartApplicationResponse StartApplication(StartApplicationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = StartApplicationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the StartApplication operation on AmazonMainframeModernizationClient. /// 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 EndStartApplication /// operation. /// REST API Reference for StartApplication Operation public virtual IAsyncResult BeginStartApplication(StartApplicationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = StartApplicationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginStartApplication. /// /// Returns a StartApplicationResult from MainframeModernization. /// REST API Reference for StartApplication Operation public virtual StartApplicationResponse EndStartApplication(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartBatchJob ///

/// Starts a batch job and returns the unique identifier of this execution of the batch /// job. The associated application must be running in order to start the batch job. ///

/// Container for the necessary parameters to execute the StartBatchJob service method. /// /// The response from the StartBatchJob service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for StartBatchJob Operation public virtual StartBatchJobResponse StartBatchJob(StartBatchJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartBatchJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartBatchJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the StartBatchJob operation on AmazonMainframeModernizationClient. /// 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 EndStartBatchJob /// operation. /// REST API Reference for StartBatchJob Operation public virtual IAsyncResult BeginStartBatchJob(StartBatchJobRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartBatchJobRequestMarshaller.Instance; options.ResponseUnmarshaller = StartBatchJobResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginStartBatchJob. /// /// Returns a StartBatchJobResult from MainframeModernization. /// REST API Reference for StartBatchJob Operation public virtual StartBatchJobResponse EndStartBatchJob(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StopApplication ///

/// Stops a running application. ///

/// Container for the necessary parameters to execute the StopApplication service method. /// /// The response from the StopApplication service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for StopApplication Operation public virtual StopApplicationResponse StopApplication(StopApplicationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StopApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = StopApplicationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the StopApplication operation on AmazonMainframeModernizationClient. /// 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 EndStopApplication /// operation. /// REST API Reference for StopApplication Operation public virtual IAsyncResult BeginStopApplication(StopApplicationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StopApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = StopApplicationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginStopApplication. /// /// Returns a StopApplicationResult from MainframeModernization. /// REST API Reference for StopApplication Operation public virtual StopApplicationResponse EndStopApplication(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource ///

/// Adds one or more tags to the specified resource. ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// One or more quotas for Amazon Web Services Mainframe Modernization exceeds the limit. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// 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 AmazonMainframeModernizationClient. /// 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 MainframeModernization. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource ///

/// Removes one or more tags from the specified resource. ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// 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 AmazonMainframeModernizationClient. /// 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 MainframeModernization. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateApplication ///

/// Updates an application and creates a new version. ///

/// Container for the necessary parameters to execute the UpdateApplication service method. /// /// The response from the UpdateApplication service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for UpdateApplication Operation public virtual UpdateApplicationResponse UpdateApplication(UpdateApplicationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateApplicationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateApplication operation on AmazonMainframeModernizationClient. /// 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 EndUpdateApplication /// operation. /// REST API Reference for UpdateApplication Operation public virtual IAsyncResult BeginUpdateApplication(UpdateApplicationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateApplicationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateApplicationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateApplication. /// /// Returns a UpdateApplicationResult from MainframeModernization. /// REST API Reference for UpdateApplication Operation public virtual UpdateApplicationResponse EndUpdateApplication(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateEnvironment ///

/// Updates the configuration details for a specific runtime environment. ///

/// Container for the necessary parameters to execute the UpdateEnvironment service method. /// /// The response from the UpdateEnvironment service method, as returned by MainframeModernization. /// /// The account or role doesn't have the right permissions to make the request. /// /// /// The parameters provided in the request conflict with existing resources. /// /// /// An unexpected error occurred during the processing of the request. /// /// /// The specified resource was not found. /// /// /// One or more quotas for Amazon Web Services Mainframe Modernization exceeds the limit. /// /// /// The number of requests made exceeds the limit. /// /// /// One or more parameters provided in the request is not valid. /// /// REST API Reference for UpdateEnvironment Operation public virtual UpdateEnvironmentResponse UpdateEnvironment(UpdateEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateEnvironment operation on AmazonMainframeModernizationClient. /// 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 EndUpdateEnvironment /// operation. /// REST API Reference for UpdateEnvironment Operation public virtual IAsyncResult BeginUpdateEnvironment(UpdateEnvironmentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateEnvironmentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateEnvironment. /// /// Returns a UpdateEnvironmentResult from MainframeModernization. /// REST API Reference for UpdateEnvironment Operation public virtual UpdateEnvironmentResponse EndUpdateEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }