/* * 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 license-manager-2018-08-01.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.LicenseManager.Model; using Amazon.LicenseManager.Model.Internal.MarshallTransformations; using Amazon.LicenseManager.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.LicenseManager { ///

/// Implementation for accessing LicenseManager /// /// License Manager makes it easier to manage licenses from software vendors across multiple /// Amazon Web Services accounts and on-premises servers. ///

public partial class AmazonLicenseManagerClient : AmazonServiceClient, IAmazonLicenseManager { private static IServiceMetadata serviceMetadata = new AmazonLicenseManagerMetadata(); #region Constructors ///

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


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

/// ///

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


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

/// ///

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

/// Constructs AmazonLicenseManagerClient with AWS Credentials ///

/// AWS Credentials public AmazonLicenseManagerClient(AWSCredentials credentials) : this(credentials, new AmazonLicenseManagerConfig()) { } ///

/// Constructs AmazonLicenseManagerClient with AWS Credentials ///

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Accepts the specified grant. ///

/// Container for the necessary parameters to execute the AcceptGrant service method. /// /// The response from the AcceptGrant service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for AcceptGrant Operation public virtual AcceptGrantResponse AcceptGrant(AcceptGrantRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptGrantResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the AcceptGrant operation on AmazonLicenseManagerClient. /// 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 EndAcceptGrant /// operation. /// REST API Reference for AcceptGrant Operation public virtual IAsyncResult BeginAcceptGrant(AcceptGrantRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptGrantResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginAcceptGrant. /// /// Returns a AcceptGrantResult from LicenseManager. /// REST API Reference for AcceptGrant Operation public virtual AcceptGrantResponse EndAcceptGrant(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CheckInLicense ///

/// Checks in the specified license. Check in a license when it is no longer in use. ///

/// Container for the necessary parameters to execute the CheckInLicense service method. /// /// The response from the CheckInLicense service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// There was a conflict processing the request. Try your request again. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for CheckInLicense Operation public virtual CheckInLicenseResponse CheckInLicense(CheckInLicenseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CheckInLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = CheckInLicenseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CheckInLicense operation on AmazonLicenseManagerClient. /// 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 EndCheckInLicense /// operation. /// REST API Reference for CheckInLicense Operation public virtual IAsyncResult BeginCheckInLicense(CheckInLicenseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CheckInLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = CheckInLicenseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCheckInLicense. /// /// Returns a CheckInLicenseResult from LicenseManager. /// REST API Reference for CheckInLicense Operation public virtual CheckInLicenseResponse EndCheckInLicense(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CheckoutBorrowLicense ///

/// Checks out the specified license for offline use. ///

/// Container for the necessary parameters to execute the CheckoutBorrowLicense service method. /// /// The response from the CheckoutBorrowLicense service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// The entitlement is not allowed. /// /// /// One or more parameter values are not valid. /// /// /// There are no entitlements found for this license, or the entitlement maximum count /// is reached. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// This is not the correct Region for the resource. Try again. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The digital signature method is unsupported. Try your request again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for CheckoutBorrowLicense Operation public virtual CheckoutBorrowLicenseResponse CheckoutBorrowLicense(CheckoutBorrowLicenseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CheckoutBorrowLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = CheckoutBorrowLicenseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CheckoutBorrowLicense operation on AmazonLicenseManagerClient. /// 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 EndCheckoutBorrowLicense /// operation. /// REST API Reference for CheckoutBorrowLicense Operation public virtual IAsyncResult BeginCheckoutBorrowLicense(CheckoutBorrowLicenseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CheckoutBorrowLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = CheckoutBorrowLicenseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCheckoutBorrowLicense. /// /// Returns a CheckoutBorrowLicenseResult from LicenseManager. /// REST API Reference for CheckoutBorrowLicense Operation public virtual CheckoutBorrowLicenseResponse EndCheckoutBorrowLicense(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CheckoutLicense ///

/// Checks out the specified license. /// /// /// /// If the account that created the license is the same that is performing the check out, /// you must specify the account as the beneficiary. /// /// ///

/// Container for the necessary parameters to execute the CheckoutLicense service method. /// /// The response from the CheckoutLicense service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// There are no entitlements found for this license, or the entitlement maximum count /// is reached. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// This is not the correct Region for the resource. Try again. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The digital signature method is unsupported. Try your request again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for CheckoutLicense Operation public virtual CheckoutLicenseResponse CheckoutLicense(CheckoutLicenseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CheckoutLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = CheckoutLicenseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CheckoutLicense operation on AmazonLicenseManagerClient. /// 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 EndCheckoutLicense /// operation. /// REST API Reference for CheckoutLicense Operation public virtual IAsyncResult BeginCheckoutLicense(CheckoutLicenseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CheckoutLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = CheckoutLicenseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCheckoutLicense. /// /// Returns a CheckoutLicenseResult from LicenseManager. /// REST API Reference for CheckoutLicense Operation public virtual CheckoutLicenseResponse EndCheckoutLicense(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateGrant ///

/// Creates a grant for the specified license. A grant shares the use of license entitlements /// with a specific Amazon Web Services account, an organization, or an organizational /// unit (OU). For more information, see Granted /// licenses in License Manager in the License Manager User Guide. ///

/// Container for the necessary parameters to execute the CreateGrant service method. /// /// The response from the CreateGrant service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for CreateGrant Operation public virtual CreateGrantResponse CreateGrant(CreateGrantRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateGrantResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateGrant operation on AmazonLicenseManagerClient. /// 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 EndCreateGrant /// operation. /// REST API Reference for CreateGrant Operation public virtual IAsyncResult BeginCreateGrant(CreateGrantRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateGrantResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateGrant. /// /// Returns a CreateGrantResult from LicenseManager. /// REST API Reference for CreateGrant Operation public virtual CreateGrantResponse EndCreateGrant(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateGrantVersion ///

/// Creates a new version of the specified grant. For more information, see Granted /// licenses in License Manager in the License Manager User Guide. ///

/// Container for the necessary parameters to execute the CreateGrantVersion service method. /// /// The response from the CreateGrantVersion service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for CreateGrantVersion Operation public virtual CreateGrantVersionResponse CreateGrantVersion(CreateGrantVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateGrantVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateGrantVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateGrantVersion operation on AmazonLicenseManagerClient. /// 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 EndCreateGrantVersion /// operation. /// REST API Reference for CreateGrantVersion Operation public virtual IAsyncResult BeginCreateGrantVersion(CreateGrantVersionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateGrantVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateGrantVersionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateGrantVersion. /// /// Returns a CreateGrantVersionResult from LicenseManager. /// REST API Reference for CreateGrantVersion Operation public virtual CreateGrantVersionResponse EndCreateGrantVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLicense ///

/// Creates a license. ///

/// Container for the necessary parameters to execute the CreateLicense service method. /// /// The response from the CreateLicense service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// This is not the correct Region for the resource. Try again. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for CreateLicense Operation public virtual CreateLicenseResponse CreateLicense(CreateLicenseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLicenseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateLicense operation on AmazonLicenseManagerClient. /// 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 EndCreateLicense /// operation. /// REST API Reference for CreateLicense Operation public virtual IAsyncResult BeginCreateLicense(CreateLicenseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLicenseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateLicense. /// /// Returns a CreateLicenseResult from LicenseManager. /// REST API Reference for CreateLicense Operation public virtual CreateLicenseResponse EndCreateLicense(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLicenseConfiguration ///

/// Creates a license configuration. /// /// /// /// A license configuration is an abstraction of a customer license agreement that can /// be consumed and enforced by License Manager. Components include specifications for /// the license type (licensing by instance, socket, CPU, or vCPU), allowed tenancy (shared /// tenancy, Dedicated Instance, Dedicated Host, or all of these), license affinity to /// host (how long a license must be associated with a host), and the number of licenses /// purchased and used. /// ///

/// Container for the necessary parameters to execute the CreateLicenseConfiguration service method. /// /// The response from the CreateLicenseConfiguration service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for CreateLicenseConfiguration Operation public virtual CreateLicenseConfigurationResponse CreateLicenseConfiguration(CreateLicenseConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLicenseConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateLicenseConfiguration operation on AmazonLicenseManagerClient. /// 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 EndCreateLicenseConfiguration /// operation. /// REST API Reference for CreateLicenseConfiguration Operation public virtual IAsyncResult BeginCreateLicenseConfiguration(CreateLicenseConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLicenseConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateLicenseConfiguration. /// /// Returns a CreateLicenseConfigurationResult from LicenseManager. /// REST API Reference for CreateLicenseConfiguration Operation public virtual CreateLicenseConfigurationResponse EndCreateLicenseConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLicenseConversionTaskForResource ///

/// Creates a new license conversion task. ///

/// Container for the necessary parameters to execute the CreateLicenseConversionTaskForResource service method. /// /// The response from the CreateLicenseConversionTaskForResource service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for CreateLicenseConversionTaskForResource Operation public virtual CreateLicenseConversionTaskForResourceResponse CreateLicenseConversionTaskForResource(CreateLicenseConversionTaskForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLicenseConversionTaskForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLicenseConversionTaskForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateLicenseConversionTaskForResource operation on AmazonLicenseManagerClient. /// 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 EndCreateLicenseConversionTaskForResource /// operation. /// REST API Reference for CreateLicenseConversionTaskForResource Operation public virtual IAsyncResult BeginCreateLicenseConversionTaskForResource(CreateLicenseConversionTaskForResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLicenseConversionTaskForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLicenseConversionTaskForResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateLicenseConversionTaskForResource. /// /// Returns a CreateLicenseConversionTaskForResourceResult from LicenseManager. /// REST API Reference for CreateLicenseConversionTaskForResource Operation public virtual CreateLicenseConversionTaskForResourceResponse EndCreateLicenseConversionTaskForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLicenseManagerReportGenerator ///

/// Creates a report generator. ///

/// Container for the necessary parameters to execute the CreateLicenseManagerReportGenerator service method. /// /// The response from the CreateLicenseManagerReportGenerator service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for CreateLicenseManagerReportGenerator Operation public virtual CreateLicenseManagerReportGeneratorResponse CreateLicenseManagerReportGenerator(CreateLicenseManagerReportGeneratorRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLicenseManagerReportGeneratorRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLicenseManagerReportGeneratorResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateLicenseManagerReportGenerator operation on AmazonLicenseManagerClient. /// 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 EndCreateLicenseManagerReportGenerator /// operation. /// REST API Reference for CreateLicenseManagerReportGenerator Operation public virtual IAsyncResult BeginCreateLicenseManagerReportGenerator(CreateLicenseManagerReportGeneratorRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLicenseManagerReportGeneratorRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLicenseManagerReportGeneratorResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateLicenseManagerReportGenerator. /// /// Returns a CreateLicenseManagerReportGeneratorResult from LicenseManager. /// REST API Reference for CreateLicenseManagerReportGenerator Operation public virtual CreateLicenseManagerReportGeneratorResponse EndCreateLicenseManagerReportGenerator(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLicenseVersion ///

/// Creates a new version of the specified license. ///

/// Container for the necessary parameters to execute the CreateLicenseVersion service method. /// /// The response from the CreateLicenseVersion service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// There was a conflict processing the request. Try your request again. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// This is not the correct Region for the resource. Try again. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for CreateLicenseVersion Operation public virtual CreateLicenseVersionResponse CreateLicenseVersion(CreateLicenseVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLicenseVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLicenseVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateLicenseVersion operation on AmazonLicenseManagerClient. /// 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 EndCreateLicenseVersion /// operation. /// REST API Reference for CreateLicenseVersion Operation public virtual IAsyncResult BeginCreateLicenseVersion(CreateLicenseVersionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLicenseVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLicenseVersionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateLicenseVersion. /// /// Returns a CreateLicenseVersionResult from LicenseManager. /// REST API Reference for CreateLicenseVersion Operation public virtual CreateLicenseVersionResponse EndCreateLicenseVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateToken ///

/// Creates a long-lived token. /// /// /// /// A refresh token is a JWT token used to get an access token. With an access token, /// you can call AssumeRoleWithWebIdentity to get role credentials that you can use to /// call License Manager to manage the specified license. /// ///

/// Container for the necessary parameters to execute the CreateToken service method. /// /// The response from the CreateToken service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// This is not the correct Region for the resource. Try again. /// /// /// Your resource limits have been exceeded. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for CreateToken Operation public virtual CreateTokenResponse CreateToken(CreateTokenRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTokenRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTokenResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateToken operation on AmazonLicenseManagerClient. /// 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 EndCreateToken /// operation. /// REST API Reference for CreateToken Operation public virtual IAsyncResult BeginCreateToken(CreateTokenRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTokenRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTokenResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateToken. /// /// Returns a CreateTokenResult from LicenseManager. /// REST API Reference for CreateToken Operation public virtual CreateTokenResponse EndCreateToken(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteGrant ///

/// Deletes the specified grant. ///

/// Container for the necessary parameters to execute the DeleteGrant service method. /// /// The response from the DeleteGrant service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for DeleteGrant Operation public virtual DeleteGrantResponse DeleteGrant(DeleteGrantRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteGrantResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteGrant operation on AmazonLicenseManagerClient. /// 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 EndDeleteGrant /// operation. /// REST API Reference for DeleteGrant Operation public virtual IAsyncResult BeginDeleteGrant(DeleteGrantRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteGrantResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteGrant. /// /// Returns a DeleteGrantResult from LicenseManager. /// REST API Reference for DeleteGrant Operation public virtual DeleteGrantResponse EndDeleteGrant(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteLicense ///

/// Deletes the specified license. ///

/// Container for the necessary parameters to execute the DeleteLicense service method. /// /// The response from the DeleteLicense service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// There was a conflict processing the request. Try your request again. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// This is not the correct Region for the resource. Try again. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for DeleteLicense Operation public virtual DeleteLicenseResponse DeleteLicense(DeleteLicenseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLicenseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteLicense operation on AmazonLicenseManagerClient. /// 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 EndDeleteLicense /// operation. /// REST API Reference for DeleteLicense Operation public virtual IAsyncResult BeginDeleteLicense(DeleteLicenseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLicenseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteLicense. /// /// Returns a DeleteLicenseResult from LicenseManager. /// REST API Reference for DeleteLicense Operation public virtual DeleteLicenseResponse EndDeleteLicense(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteLicenseConfiguration ///

/// Deletes the specified license configuration. /// /// /// /// You cannot delete a license configuration that is in use. /// ///

/// Container for the necessary parameters to execute the DeleteLicenseConfiguration service method. /// /// The response from the DeleteLicenseConfiguration service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for DeleteLicenseConfiguration Operation public virtual DeleteLicenseConfigurationResponse DeleteLicenseConfiguration(DeleteLicenseConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLicenseConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteLicenseConfiguration operation on AmazonLicenseManagerClient. /// 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 EndDeleteLicenseConfiguration /// operation. /// REST API Reference for DeleteLicenseConfiguration Operation public virtual IAsyncResult BeginDeleteLicenseConfiguration(DeleteLicenseConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLicenseConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteLicenseConfiguration. /// /// Returns a DeleteLicenseConfigurationResult from LicenseManager. /// REST API Reference for DeleteLicenseConfiguration Operation public virtual DeleteLicenseConfigurationResponse EndDeleteLicenseConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteLicenseManagerReportGenerator ///

/// Deletes the specified report generator. /// /// /// /// This action deletes the report generator, which stops it from generating future reports. /// The action cannot be reversed. It has no effect on the previous reports from this /// generator. /// ///

/// Container for the necessary parameters to execute the DeleteLicenseManagerReportGenerator service method. /// /// The response from the DeleteLicenseManagerReportGenerator service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for DeleteLicenseManagerReportGenerator Operation public virtual DeleteLicenseManagerReportGeneratorResponse DeleteLicenseManagerReportGenerator(DeleteLicenseManagerReportGeneratorRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLicenseManagerReportGeneratorRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLicenseManagerReportGeneratorResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteLicenseManagerReportGenerator operation on AmazonLicenseManagerClient. /// 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 EndDeleteLicenseManagerReportGenerator /// operation. /// REST API Reference for DeleteLicenseManagerReportGenerator Operation public virtual IAsyncResult BeginDeleteLicenseManagerReportGenerator(DeleteLicenseManagerReportGeneratorRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLicenseManagerReportGeneratorRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLicenseManagerReportGeneratorResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteLicenseManagerReportGenerator. /// /// Returns a DeleteLicenseManagerReportGeneratorResult from LicenseManager. /// REST API Reference for DeleteLicenseManagerReportGenerator Operation public virtual DeleteLicenseManagerReportGeneratorResponse EndDeleteLicenseManagerReportGenerator(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteToken ///

/// Deletes the specified token. Must be called in the license home Region. ///

/// Container for the necessary parameters to execute the DeleteToken service method. /// /// The response from the DeleteToken service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// This is not the correct Region for the resource. Try again. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for DeleteToken Operation public virtual DeleteTokenResponse DeleteToken(DeleteTokenRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTokenRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTokenResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteToken operation on AmazonLicenseManagerClient. /// 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 EndDeleteToken /// operation. /// REST API Reference for DeleteToken Operation public virtual IAsyncResult BeginDeleteToken(DeleteTokenRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTokenRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTokenResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteToken. /// /// Returns a DeleteTokenResult from LicenseManager. /// REST API Reference for DeleteToken Operation public virtual DeleteTokenResponse EndDeleteToken(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ExtendLicenseConsumption ///

/// Extends the expiration date for license consumption. ///

/// Container for the necessary parameters to execute the ExtendLicenseConsumption service method. /// /// The response from the ExtendLicenseConsumption service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for ExtendLicenseConsumption Operation public virtual ExtendLicenseConsumptionResponse ExtendLicenseConsumption(ExtendLicenseConsumptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ExtendLicenseConsumptionRequestMarshaller.Instance; options.ResponseUnmarshaller = ExtendLicenseConsumptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ExtendLicenseConsumption operation on AmazonLicenseManagerClient. /// 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 EndExtendLicenseConsumption /// operation. /// REST API Reference for ExtendLicenseConsumption Operation public virtual IAsyncResult BeginExtendLicenseConsumption(ExtendLicenseConsumptionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ExtendLicenseConsumptionRequestMarshaller.Instance; options.ResponseUnmarshaller = ExtendLicenseConsumptionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginExtendLicenseConsumption. /// /// Returns a ExtendLicenseConsumptionResult from LicenseManager. /// REST API Reference for ExtendLicenseConsumption Operation public virtual ExtendLicenseConsumptionResponse EndExtendLicenseConsumption(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetAccessToken ///

/// Gets a temporary access token to use with AssumeRoleWithWebIdentity. Access tokens /// are valid for one hour. ///

/// Container for the necessary parameters to execute the GetAccessToken service method. /// /// The response from the GetAccessToken service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for GetAccessToken Operation public virtual GetAccessTokenResponse GetAccessToken(GetAccessTokenRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAccessTokenRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAccessTokenResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetAccessToken operation on AmazonLicenseManagerClient. /// 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 EndGetAccessToken /// operation. /// REST API Reference for GetAccessToken Operation public virtual IAsyncResult BeginGetAccessToken(GetAccessTokenRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetAccessTokenRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAccessTokenResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetAccessToken. /// /// Returns a GetAccessTokenResult from LicenseManager. /// REST API Reference for GetAccessToken Operation public virtual GetAccessTokenResponse EndGetAccessToken(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetGrant ///

/// Gets detailed information about the specified grant. ///

/// Container for the necessary parameters to execute the GetGrant service method. /// /// The response from the GetGrant service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for GetGrant Operation public virtual GetGrantResponse GetGrant(GetGrantRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = GetGrantResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetGrant operation on AmazonLicenseManagerClient. /// 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 EndGetGrant /// operation. /// REST API Reference for GetGrant Operation public virtual IAsyncResult BeginGetGrant(GetGrantRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = GetGrantResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetGrant. /// /// Returns a GetGrantResult from LicenseManager. /// REST API Reference for GetGrant Operation public virtual GetGrantResponse EndGetGrant(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLicense ///

/// Gets detailed information about the specified license. ///

/// Container for the necessary parameters to execute the GetLicense service method. /// /// The response from the GetLicense service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for GetLicense Operation public virtual GetLicenseResponse GetLicense(GetLicenseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLicenseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetLicense operation on AmazonLicenseManagerClient. /// 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 EndGetLicense /// operation. /// REST API Reference for GetLicense Operation public virtual IAsyncResult BeginGetLicense(GetLicenseRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLicenseRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLicenseResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetLicense. /// /// Returns a GetLicenseResult from LicenseManager. /// REST API Reference for GetLicense Operation public virtual GetLicenseResponse EndGetLicense(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLicenseConfiguration ///

/// Gets detailed information about the specified license configuration. ///

/// Container for the necessary parameters to execute the GetLicenseConfiguration service method. /// /// The response from the GetLicenseConfiguration service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for GetLicenseConfiguration Operation public virtual GetLicenseConfigurationResponse GetLicenseConfiguration(GetLicenseConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLicenseConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetLicenseConfiguration operation on AmazonLicenseManagerClient. /// 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 EndGetLicenseConfiguration /// operation. /// REST API Reference for GetLicenseConfiguration Operation public virtual IAsyncResult BeginGetLicenseConfiguration(GetLicenseConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLicenseConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetLicenseConfiguration. /// /// Returns a GetLicenseConfigurationResult from LicenseManager. /// REST API Reference for GetLicenseConfiguration Operation public virtual GetLicenseConfigurationResponse EndGetLicenseConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLicenseConversionTask ///

/// Gets information about the specified license type conversion task. ///

/// Container for the necessary parameters to execute the GetLicenseConversionTask service method. /// /// The response from the GetLicenseConversionTask service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for GetLicenseConversionTask Operation public virtual GetLicenseConversionTaskResponse GetLicenseConversionTask(GetLicenseConversionTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLicenseConversionTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLicenseConversionTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetLicenseConversionTask operation on AmazonLicenseManagerClient. /// 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 EndGetLicenseConversionTask /// operation. /// REST API Reference for GetLicenseConversionTask Operation public virtual IAsyncResult BeginGetLicenseConversionTask(GetLicenseConversionTaskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLicenseConversionTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLicenseConversionTaskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetLicenseConversionTask. /// /// Returns a GetLicenseConversionTaskResult from LicenseManager. /// REST API Reference for GetLicenseConversionTask Operation public virtual GetLicenseConversionTaskResponse EndGetLicenseConversionTask(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLicenseManagerReportGenerator ///

/// Gets information about the specified report generator. ///

/// Container for the necessary parameters to execute the GetLicenseManagerReportGenerator service method. /// /// The response from the GetLicenseManagerReportGenerator service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for GetLicenseManagerReportGenerator Operation public virtual GetLicenseManagerReportGeneratorResponse GetLicenseManagerReportGenerator(GetLicenseManagerReportGeneratorRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLicenseManagerReportGeneratorRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLicenseManagerReportGeneratorResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetLicenseManagerReportGenerator operation on AmazonLicenseManagerClient. /// 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 EndGetLicenseManagerReportGenerator /// operation. /// REST API Reference for GetLicenseManagerReportGenerator Operation public virtual IAsyncResult BeginGetLicenseManagerReportGenerator(GetLicenseManagerReportGeneratorRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLicenseManagerReportGeneratorRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLicenseManagerReportGeneratorResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetLicenseManagerReportGenerator. /// /// Returns a GetLicenseManagerReportGeneratorResult from LicenseManager. /// REST API Reference for GetLicenseManagerReportGenerator Operation public virtual GetLicenseManagerReportGeneratorResponse EndGetLicenseManagerReportGenerator(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLicenseUsage ///

/// Gets detailed information about the usage of the specified license. ///

/// Container for the necessary parameters to execute the GetLicenseUsage service method. /// /// The response from the GetLicenseUsage service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for GetLicenseUsage Operation public virtual GetLicenseUsageResponse GetLicenseUsage(GetLicenseUsageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLicenseUsageRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLicenseUsageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetLicenseUsage operation on AmazonLicenseManagerClient. /// 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 EndGetLicenseUsage /// operation. /// REST API Reference for GetLicenseUsage Operation public virtual IAsyncResult BeginGetLicenseUsage(GetLicenseUsageRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLicenseUsageRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLicenseUsageResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetLicenseUsage. /// /// Returns a GetLicenseUsageResult from LicenseManager. /// REST API Reference for GetLicenseUsage Operation public virtual GetLicenseUsageResponse EndGetLicenseUsage(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetServiceSettings ///

/// Gets the License Manager settings for the current Region. ///

/// Container for the necessary parameters to execute the GetServiceSettings service method. /// /// The response from the GetServiceSettings service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for GetServiceSettings Operation public virtual GetServiceSettingsResponse GetServiceSettings(GetServiceSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetServiceSettings operation on AmazonLicenseManagerClient. /// 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 EndGetServiceSettings /// operation. /// REST API Reference for GetServiceSettings Operation public virtual IAsyncResult BeginGetServiceSettings(GetServiceSettingsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceSettingsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetServiceSettings. /// /// Returns a GetServiceSettingsResult from LicenseManager. /// REST API Reference for GetServiceSettings Operation public virtual GetServiceSettingsResponse EndGetServiceSettings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListAssociationsForLicenseConfiguration ///

/// Lists the resource associations for the specified license configuration. /// /// /// /// Resource associations need not consume licenses from a license configuration. For /// example, an AMI or a stopped instance might not consume a license (depending on the /// license rules). /// ///

/// Container for the necessary parameters to execute the ListAssociationsForLicenseConfiguration service method. /// /// The response from the ListAssociationsForLicenseConfiguration service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// The request uses too many filters or too many filter values. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for ListAssociationsForLicenseConfiguration Operation public virtual ListAssociationsForLicenseConfigurationResponse ListAssociationsForLicenseConfiguration(ListAssociationsForLicenseConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssociationsForLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssociationsForLicenseConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListAssociationsForLicenseConfiguration operation on AmazonLicenseManagerClient. /// 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 EndListAssociationsForLicenseConfiguration /// operation. /// REST API Reference for ListAssociationsForLicenseConfiguration Operation public virtual IAsyncResult BeginListAssociationsForLicenseConfiguration(ListAssociationsForLicenseConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssociationsForLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssociationsForLicenseConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListAssociationsForLicenseConfiguration. /// /// Returns a ListAssociationsForLicenseConfigurationResult from LicenseManager. /// REST API Reference for ListAssociationsForLicenseConfiguration Operation public virtual ListAssociationsForLicenseConfigurationResponse EndListAssociationsForLicenseConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListDistributedGrants ///

/// Lists the grants distributed for the specified license. ///

/// Container for the necessary parameters to execute the ListDistributedGrants service method. /// /// The response from the ListDistributedGrants service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for ListDistributedGrants Operation public virtual ListDistributedGrantsResponse ListDistributedGrants(ListDistributedGrantsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDistributedGrantsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDistributedGrantsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListDistributedGrants operation on AmazonLicenseManagerClient. /// 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 EndListDistributedGrants /// operation. /// REST API Reference for ListDistributedGrants Operation public virtual IAsyncResult BeginListDistributedGrants(ListDistributedGrantsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListDistributedGrantsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDistributedGrantsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListDistributedGrants. /// /// Returns a ListDistributedGrantsResult from LicenseManager. /// REST API Reference for ListDistributedGrants Operation public virtual ListDistributedGrantsResponse EndListDistributedGrants(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListFailuresForLicenseConfigurationOperations ///

/// Lists the license configuration operations that failed. ///

/// Container for the necessary parameters to execute the ListFailuresForLicenseConfigurationOperations service method. /// /// The response from the ListFailuresForLicenseConfigurationOperations service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for ListFailuresForLicenseConfigurationOperations Operation public virtual ListFailuresForLicenseConfigurationOperationsResponse ListFailuresForLicenseConfigurationOperations(ListFailuresForLicenseConfigurationOperationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListFailuresForLicenseConfigurationOperationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListFailuresForLicenseConfigurationOperationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListFailuresForLicenseConfigurationOperations operation on AmazonLicenseManagerClient. /// 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 EndListFailuresForLicenseConfigurationOperations /// operation. /// REST API Reference for ListFailuresForLicenseConfigurationOperations Operation public virtual IAsyncResult BeginListFailuresForLicenseConfigurationOperations(ListFailuresForLicenseConfigurationOperationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListFailuresForLicenseConfigurationOperationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListFailuresForLicenseConfigurationOperationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListFailuresForLicenseConfigurationOperations. /// /// Returns a ListFailuresForLicenseConfigurationOperationsResult from LicenseManager. /// REST API Reference for ListFailuresForLicenseConfigurationOperations Operation public virtual ListFailuresForLicenseConfigurationOperationsResponse EndListFailuresForLicenseConfigurationOperations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLicenseConfigurations ///

/// Lists the license configurations for your account. ///

/// Container for the necessary parameters to execute the ListLicenseConfigurations service method. /// /// The response from the ListLicenseConfigurations service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// The request uses too many filters or too many filter values. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for ListLicenseConfigurations Operation public virtual ListLicenseConfigurationsResponse ListLicenseConfigurations(ListLicenseConfigurationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicenseConfigurationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicenseConfigurationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListLicenseConfigurations operation on AmazonLicenseManagerClient. /// 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 EndListLicenseConfigurations /// operation. /// REST API Reference for ListLicenseConfigurations Operation public virtual IAsyncResult BeginListLicenseConfigurations(ListLicenseConfigurationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicenseConfigurationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicenseConfigurationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListLicenseConfigurations. /// /// Returns a ListLicenseConfigurationsResult from LicenseManager. /// REST API Reference for ListLicenseConfigurations Operation public virtual ListLicenseConfigurationsResponse EndListLicenseConfigurations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLicenseConversionTasks ///

/// Lists the license type conversion tasks for your account. ///

/// Container for the necessary parameters to execute the ListLicenseConversionTasks service method. /// /// The response from the ListLicenseConversionTasks service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for ListLicenseConversionTasks Operation public virtual ListLicenseConversionTasksResponse ListLicenseConversionTasks(ListLicenseConversionTasksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicenseConversionTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicenseConversionTasksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListLicenseConversionTasks operation on AmazonLicenseManagerClient. /// 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 EndListLicenseConversionTasks /// operation. /// REST API Reference for ListLicenseConversionTasks Operation public virtual IAsyncResult BeginListLicenseConversionTasks(ListLicenseConversionTasksRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicenseConversionTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicenseConversionTasksResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListLicenseConversionTasks. /// /// Returns a ListLicenseConversionTasksResult from LicenseManager. /// REST API Reference for ListLicenseConversionTasks Operation public virtual ListLicenseConversionTasksResponse EndListLicenseConversionTasks(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLicenseManagerReportGenerators ///

/// Lists the report generators for your account. ///

/// Container for the necessary parameters to execute the ListLicenseManagerReportGenerators service method. /// /// The response from the ListLicenseManagerReportGenerators service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for ListLicenseManagerReportGenerators Operation public virtual ListLicenseManagerReportGeneratorsResponse ListLicenseManagerReportGenerators(ListLicenseManagerReportGeneratorsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicenseManagerReportGeneratorsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicenseManagerReportGeneratorsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListLicenseManagerReportGenerators operation on AmazonLicenseManagerClient. /// 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 EndListLicenseManagerReportGenerators /// operation. /// REST API Reference for ListLicenseManagerReportGenerators Operation public virtual IAsyncResult BeginListLicenseManagerReportGenerators(ListLicenseManagerReportGeneratorsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicenseManagerReportGeneratorsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicenseManagerReportGeneratorsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListLicenseManagerReportGenerators. /// /// Returns a ListLicenseManagerReportGeneratorsResult from LicenseManager. /// REST API Reference for ListLicenseManagerReportGenerators Operation public virtual ListLicenseManagerReportGeneratorsResponse EndListLicenseManagerReportGenerators(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLicenses ///

/// Lists the licenses for your account. ///

/// Container for the necessary parameters to execute the ListLicenses service method. /// /// The response from the ListLicenses service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for ListLicenses Operation public virtual ListLicensesResponse ListLicenses(ListLicensesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicensesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicensesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListLicenses operation on AmazonLicenseManagerClient. /// 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 EndListLicenses /// operation. /// REST API Reference for ListLicenses Operation public virtual IAsyncResult BeginListLicenses(ListLicensesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicensesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicensesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListLicenses. /// /// Returns a ListLicensesResult from LicenseManager. /// REST API Reference for ListLicenses Operation public virtual ListLicensesResponse EndListLicenses(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLicenseSpecificationsForResource ///

/// Describes the license configurations for the specified resource. ///

/// Container for the necessary parameters to execute the ListLicenseSpecificationsForResource service method. /// /// The response from the ListLicenseSpecificationsForResource service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for ListLicenseSpecificationsForResource Operation public virtual ListLicenseSpecificationsForResourceResponse ListLicenseSpecificationsForResource(ListLicenseSpecificationsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicenseSpecificationsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicenseSpecificationsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListLicenseSpecificationsForResource operation on AmazonLicenseManagerClient. /// 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 EndListLicenseSpecificationsForResource /// operation. /// REST API Reference for ListLicenseSpecificationsForResource Operation public virtual IAsyncResult BeginListLicenseSpecificationsForResource(ListLicenseSpecificationsForResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicenseSpecificationsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicenseSpecificationsForResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListLicenseSpecificationsForResource. /// /// Returns a ListLicenseSpecificationsForResourceResult from LicenseManager. /// REST API Reference for ListLicenseSpecificationsForResource Operation public virtual ListLicenseSpecificationsForResourceResponse EndListLicenseSpecificationsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLicenseVersions ///

/// Lists all versions of the specified license. ///

/// Container for the necessary parameters to execute the ListLicenseVersions service method. /// /// The response from the ListLicenseVersions service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for ListLicenseVersions Operation public virtual ListLicenseVersionsResponse ListLicenseVersions(ListLicenseVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicenseVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicenseVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListLicenseVersions operation on AmazonLicenseManagerClient. /// 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 EndListLicenseVersions /// operation. /// REST API Reference for ListLicenseVersions Operation public virtual IAsyncResult BeginListLicenseVersions(ListLicenseVersionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLicenseVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLicenseVersionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListLicenseVersions. /// /// Returns a ListLicenseVersionsResult from LicenseManager. /// REST API Reference for ListLicenseVersions Operation public virtual ListLicenseVersionsResponse EndListLicenseVersions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReceivedGrants ///

/// Lists grants that are received. Received grants are grants created while specifying /// the recipient as this Amazon Web Services account, your organization, or an organizational /// unit (OU) to which this member account belongs. ///

/// Container for the necessary parameters to execute the ListReceivedGrants service method. /// /// The response from the ListReceivedGrants service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for ListReceivedGrants Operation public virtual ListReceivedGrantsResponse ListReceivedGrants(ListReceivedGrantsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReceivedGrantsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReceivedGrantsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListReceivedGrants operation on AmazonLicenseManagerClient. /// 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 EndListReceivedGrants /// operation. /// REST API Reference for ListReceivedGrants Operation public virtual IAsyncResult BeginListReceivedGrants(ListReceivedGrantsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReceivedGrantsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReceivedGrantsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListReceivedGrants. /// /// Returns a ListReceivedGrantsResult from LicenseManager. /// REST API Reference for ListReceivedGrants Operation public virtual ListReceivedGrantsResponse EndListReceivedGrants(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReceivedGrantsForOrganization ///

/// Lists the grants received for all accounts in the organization. ///

/// Container for the necessary parameters to execute the ListReceivedGrantsForOrganization service method. /// /// The response from the ListReceivedGrantsForOrganization service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for ListReceivedGrantsForOrganization Operation public virtual ListReceivedGrantsForOrganizationResponse ListReceivedGrantsForOrganization(ListReceivedGrantsForOrganizationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReceivedGrantsForOrganizationRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReceivedGrantsForOrganizationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListReceivedGrantsForOrganization operation on AmazonLicenseManagerClient. /// 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 EndListReceivedGrantsForOrganization /// operation. /// REST API Reference for ListReceivedGrantsForOrganization Operation public virtual IAsyncResult BeginListReceivedGrantsForOrganization(ListReceivedGrantsForOrganizationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReceivedGrantsForOrganizationRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReceivedGrantsForOrganizationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListReceivedGrantsForOrganization. /// /// Returns a ListReceivedGrantsForOrganizationResult from LicenseManager. /// REST API Reference for ListReceivedGrantsForOrganization Operation public virtual ListReceivedGrantsForOrganizationResponse EndListReceivedGrantsForOrganization(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReceivedLicenses ///

/// Lists received licenses. ///

/// Container for the necessary parameters to execute the ListReceivedLicenses service method. /// /// The response from the ListReceivedLicenses service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for ListReceivedLicenses Operation public virtual ListReceivedLicensesResponse ListReceivedLicenses(ListReceivedLicensesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReceivedLicensesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReceivedLicensesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListReceivedLicenses operation on AmazonLicenseManagerClient. /// 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 EndListReceivedLicenses /// operation. /// REST API Reference for ListReceivedLicenses Operation public virtual IAsyncResult BeginListReceivedLicenses(ListReceivedLicensesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReceivedLicensesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReceivedLicensesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListReceivedLicenses. /// /// Returns a ListReceivedLicensesResult from LicenseManager. /// REST API Reference for ListReceivedLicenses Operation public virtual ListReceivedLicensesResponse EndListReceivedLicenses(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReceivedLicensesForOrganization ///

/// Lists the licenses received for all accounts in the organization. ///

/// Container for the necessary parameters to execute the ListReceivedLicensesForOrganization service method. /// /// The response from the ListReceivedLicensesForOrganization service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for ListReceivedLicensesForOrganization Operation public virtual ListReceivedLicensesForOrganizationResponse ListReceivedLicensesForOrganization(ListReceivedLicensesForOrganizationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReceivedLicensesForOrganizationRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReceivedLicensesForOrganizationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListReceivedLicensesForOrganization operation on AmazonLicenseManagerClient. /// 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 EndListReceivedLicensesForOrganization /// operation. /// REST API Reference for ListReceivedLicensesForOrganization Operation public virtual IAsyncResult BeginListReceivedLicensesForOrganization(ListReceivedLicensesForOrganizationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReceivedLicensesForOrganizationRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReceivedLicensesForOrganizationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListReceivedLicensesForOrganization. /// /// Returns a ListReceivedLicensesForOrganizationResult from LicenseManager. /// REST API Reference for ListReceivedLicensesForOrganization Operation public virtual ListReceivedLicensesForOrganizationResponse EndListReceivedLicensesForOrganization(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListResourceInventory ///

/// Lists resources managed using Systems Manager inventory. ///

/// Container for the necessary parameters to execute the ListResourceInventory service method. /// /// The response from the ListResourceInventory service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// A dependency required to run the API is missing. /// /// /// The request uses too many filters or too many filter values. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for ListResourceInventory Operation public virtual ListResourceInventoryResponse ListResourceInventory(ListResourceInventoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourceInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourceInventoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListResourceInventory operation on AmazonLicenseManagerClient. /// 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 EndListResourceInventory /// operation. /// REST API Reference for ListResourceInventory Operation public virtual IAsyncResult BeginListResourceInventory(ListResourceInventoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourceInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourceInventoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListResourceInventory. /// /// Returns a ListResourceInventoryResult from LicenseManager. /// REST API Reference for ListResourceInventory Operation public virtual ListResourceInventoryResponse EndListResourceInventory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

/// Lists the tags for the specified license configuration. ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// 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 AmazonLicenseManagerClient. /// 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 LicenseManager. /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTokens ///

/// Lists your tokens. ///

/// Container for the necessary parameters to execute the ListTokens service method. /// /// The response from the ListTokens service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for ListTokens Operation public virtual ListTokensResponse ListTokens(ListTokensRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTokensRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTokensResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListTokens operation on AmazonLicenseManagerClient. /// 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 EndListTokens /// operation. /// REST API Reference for ListTokens Operation public virtual IAsyncResult BeginListTokens(ListTokensRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListTokensRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTokensResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListTokens. /// /// Returns a ListTokensResult from LicenseManager. /// REST API Reference for ListTokens Operation public virtual ListTokensResponse EndListTokens(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListUsageForLicenseConfiguration ///

/// Lists all license usage records for a license configuration, displaying license consumption /// details by resource at a selected point in time. Use this action to audit the current /// license consumption for any license inventory and configuration. ///

/// Container for the necessary parameters to execute the ListUsageForLicenseConfiguration service method. /// /// The response from the ListUsageForLicenseConfiguration service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// The request uses too many filters or too many filter values. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for ListUsageForLicenseConfiguration Operation public virtual ListUsageForLicenseConfigurationResponse ListUsageForLicenseConfiguration(ListUsageForLicenseConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListUsageForLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = ListUsageForLicenseConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListUsageForLicenseConfiguration operation on AmazonLicenseManagerClient. /// 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 EndListUsageForLicenseConfiguration /// operation. /// REST API Reference for ListUsageForLicenseConfiguration Operation public virtual IAsyncResult BeginListUsageForLicenseConfiguration(ListUsageForLicenseConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListUsageForLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = ListUsageForLicenseConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListUsageForLicenseConfiguration. /// /// Returns a ListUsageForLicenseConfigurationResult from LicenseManager. /// REST API Reference for ListUsageForLicenseConfiguration Operation public virtual ListUsageForLicenseConfigurationResponse EndListUsageForLicenseConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RejectGrant ///

/// Rejects the specified grant. ///

/// Container for the necessary parameters to execute the RejectGrant service method. /// /// The response from the RejectGrant service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for RejectGrant Operation public virtual RejectGrantResponse RejectGrant(RejectGrantRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RejectGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectGrantResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the RejectGrant operation on AmazonLicenseManagerClient. /// 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 EndRejectGrant /// operation. /// REST API Reference for RejectGrant Operation public virtual IAsyncResult BeginRejectGrant(RejectGrantRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RejectGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectGrantResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginRejectGrant. /// /// Returns a RejectGrantResult from LicenseManager. /// REST API Reference for RejectGrant Operation public virtual RejectGrantResponse EndRejectGrant(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource ///

/// Adds the specified tags to the specified license configuration. ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// 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 AmazonLicenseManagerClient. /// 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 LicenseManager. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource ///

/// Removes the specified tags from the specified license configuration. ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// 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 AmazonLicenseManagerClient. /// 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 LicenseManager. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateLicenseConfiguration ///

/// Modifies the attributes of an existing license configuration. ///

/// Container for the necessary parameters to execute the UpdateLicenseConfiguration service method. /// /// The response from the UpdateLicenseConfiguration service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for UpdateLicenseConfiguration Operation public virtual UpdateLicenseConfigurationResponse UpdateLicenseConfiguration(UpdateLicenseConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLicenseConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateLicenseConfiguration operation on AmazonLicenseManagerClient. /// 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 EndUpdateLicenseConfiguration /// operation. /// REST API Reference for UpdateLicenseConfiguration Operation public virtual IAsyncResult BeginUpdateLicenseConfiguration(UpdateLicenseConfigurationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLicenseConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLicenseConfigurationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateLicenseConfiguration. /// /// Returns a UpdateLicenseConfigurationResult from LicenseManager. /// REST API Reference for UpdateLicenseConfiguration Operation public virtual UpdateLicenseConfigurationResponse EndUpdateLicenseConfiguration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateLicenseManagerReportGenerator ///

/// Updates a report generator. /// /// /// /// After you make changes to a report generator, it starts generating new reports within /// 60 minutes of being updated. /// ///

/// Container for the necessary parameters to execute the UpdateLicenseManagerReportGenerator service method. /// /// The response from the UpdateLicenseManagerReportGenerator service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// Your resource limits have been exceeded. /// /// /// The resource cannot be found. /// /// /// The server experienced an internal error. Try again. /// /// /// The provided input is not valid. Try your request again. /// /// REST API Reference for UpdateLicenseManagerReportGenerator Operation public virtual UpdateLicenseManagerReportGeneratorResponse UpdateLicenseManagerReportGenerator(UpdateLicenseManagerReportGeneratorRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLicenseManagerReportGeneratorRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLicenseManagerReportGeneratorResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateLicenseManagerReportGenerator operation on AmazonLicenseManagerClient. /// 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 EndUpdateLicenseManagerReportGenerator /// operation. /// REST API Reference for UpdateLicenseManagerReportGenerator Operation public virtual IAsyncResult BeginUpdateLicenseManagerReportGenerator(UpdateLicenseManagerReportGeneratorRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLicenseManagerReportGeneratorRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLicenseManagerReportGeneratorResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateLicenseManagerReportGenerator. /// /// Returns a UpdateLicenseManagerReportGeneratorResult from LicenseManager. /// REST API Reference for UpdateLicenseManagerReportGenerator Operation public virtual UpdateLicenseManagerReportGeneratorResponse EndUpdateLicenseManagerReportGenerator(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateLicenseSpecificationsForResource ///

/// Adds or removes the specified license configurations for the specified Amazon Web /// Services resource. /// /// /// /// You can update the license specifications of AMIs, instances, and hosts. You cannot /// update the license specifications for launch templates and CloudFormation templates, /// as they send license configurations to the operation that creates the resource. /// ///

/// Container for the necessary parameters to execute the UpdateLicenseSpecificationsForResource service method. /// /// The response from the UpdateLicenseSpecificationsForResource service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// License Manager cannot allocate a license to a resource because of its state. /// /// /// /// For example, you cannot allocate a license to an instance in the process of shutting /// down. /// /// /// /// You do not have enough licenses available to support a new resource launch. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for UpdateLicenseSpecificationsForResource Operation public virtual UpdateLicenseSpecificationsForResourceResponse UpdateLicenseSpecificationsForResource(UpdateLicenseSpecificationsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLicenseSpecificationsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLicenseSpecificationsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateLicenseSpecificationsForResource operation on AmazonLicenseManagerClient. /// 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 EndUpdateLicenseSpecificationsForResource /// operation. /// REST API Reference for UpdateLicenseSpecificationsForResource Operation public virtual IAsyncResult BeginUpdateLicenseSpecificationsForResource(UpdateLicenseSpecificationsForResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLicenseSpecificationsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLicenseSpecificationsForResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateLicenseSpecificationsForResource. /// /// Returns a UpdateLicenseSpecificationsForResourceResult from LicenseManager. /// REST API Reference for UpdateLicenseSpecificationsForResource Operation public virtual UpdateLicenseSpecificationsForResourceResponse EndUpdateLicenseSpecificationsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateServiceSettings ///

/// Updates License Manager settings for the current Region. ///

/// Container for the necessary parameters to execute the UpdateServiceSettings service method. /// /// The response from the UpdateServiceSettings service method, as returned by LicenseManager. /// /// Access to resource denied. /// /// /// The Amazon Web Services user account does not have permission to perform the action. /// Check the IAM policy associated with this account. /// /// /// One or more parameter values are not valid. /// /// /// Too many requests have been submitted. Try again after a brief wait. /// /// /// The server experienced an internal error. Try again. /// /// REST API Reference for UpdateServiceSettings Operation public virtual UpdateServiceSettingsResponse UpdateServiceSettings(UpdateServiceSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateServiceSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateServiceSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateServiceSettings operation on AmazonLicenseManagerClient. /// 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 EndUpdateServiceSettings /// operation. /// REST API Reference for UpdateServiceSettings Operation public virtual IAsyncResult BeginUpdateServiceSettings(UpdateServiceSettingsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateServiceSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateServiceSettingsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateServiceSettings. /// /// Returns a UpdateServiceSettingsResult from LicenseManager. /// REST API Reference for UpdateServiceSettings Operation public virtual UpdateServiceSettingsResponse EndUpdateServiceSettings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }