/*
* 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 vpc-lattice-2022-11-30.normal.json service model.
*/
using System;
using System.Collections.Generic;
using System.Net;
using Amazon.VPCLattice.Model;
using Amazon.VPCLattice.Model.Internal.MarshallTransformations;
using Amazon.VPCLattice.Internal;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Auth;
using Amazon.Runtime.Internal.Transform;
namespace Amazon.VPCLattice
{
/// <summary>
/// Implementation for accessing VPCLattice
///
/// Amazon VPC Lattice is a fully managed application networking service that you use
/// to connect, secure, and monitor all of your services across multiple accounts and
/// virtual private clouds (VPCs). Amazon VPC Lattice interconnects your microservices
/// and legacy services within a logical boundary, so that you can discover and manage
/// them more efficiently. For more information, see the <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/">Amazon
/// VPC Lattice User Guide</a>
/// </summary>
public partial class AmazonVPCLatticeClient : AmazonServiceClient, IAmazonVPCLattice
{
private static IServiceMetadata serviceMetadata = new AmazonVPCLatticeMetadata();
#if BCL45 || AWS_ASYNC_ENUMERABLES_API
private IVPCLatticePaginatorFactory _paginators;
/// <summary>
/// Paginators for the service
/// </summary>
public IVPCLatticePaginatorFactory Paginators
{
get
{
if (this._paginators == null)
{
this._paginators = new VPCLatticePaginatorFactory(this);
}
return this._paginators;
}
}
#endif
#region Constructors
/// <summary>
/// Constructs AmazonVPCLatticeClient 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.
/// <code>
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
/// </code>
///
/// </summary>
public AmazonVPCLatticeClient()
: base(FallbackCredentialsFactory.GetCredentials(), new AmazonVPCLatticeConfig()) { }
/// <summary>
/// Constructs AmazonVPCLatticeClient 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.
/// <code>
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
/// </code>
///
/// </summary>
/// <param name="region">The region to connect.</param>
public AmazonVPCLatticeClient(RegionEndpoint region)
: base(FallbackCredentialsFactory.GetCredentials(), new AmazonVPCLatticeConfig{RegionEndpoint = region}) { }
/// <summary>
/// Constructs AmazonVPCLatticeClient 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.
/// <code>
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
/// </code>
///
/// </summary>
/// <param name="config">The AmazonVPCLatticeClient Configuration Object</param>
public AmazonVPCLatticeClient(AmazonVPCLatticeConfig config)
: base(FallbackCredentialsFactory.GetCredentials(config), config){}
/// <summary>
/// Constructs AmazonVPCLatticeClient with AWS Credentials
/// </summary>
/// <param name="credentials">AWS Credentials</param>
public AmazonVPCLatticeClient(AWSCredentials credentials)
: this(credentials, new AmazonVPCLatticeConfig())
{
}
/// <summary>
/// Constructs AmazonVPCLatticeClient with AWS Credentials
/// </summary>
/// <param name="credentials">AWS Credentials</param>
/// <param name="region">The region to connect.</param>
public AmazonVPCLatticeClient(AWSCredentials credentials, RegionEndpoint region)
: this(credentials, new AmazonVPCLatticeConfig{RegionEndpoint = region})
{
}
/// <summary>
/// Constructs AmazonVPCLatticeClient with AWS Credentials and an
/// AmazonVPCLatticeClient Configuration object.
/// </summary>
/// <param name="credentials">AWS Credentials</param>
/// <param name="clientConfig">The AmazonVPCLatticeClient Configuration Object</param>
public AmazonVPCLatticeClient(AWSCredentials credentials, AmazonVPCLatticeConfig clientConfig)
: base(credentials, clientConfig)
{
}
/// <summary>
/// Constructs AmazonVPCLatticeClient with AWS Access Key ID and AWS Secret Key
/// </summary>
/// <param name="awsAccessKeyId">AWS Access Key ID</param>
/// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
public AmazonVPCLatticeClient(string awsAccessKeyId, string awsSecretAccessKey)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonVPCLatticeConfig())
{
}
/// <summary>
/// Constructs AmazonVPCLatticeClient with AWS Access Key ID and AWS Secret Key
/// </summary>
/// <param name="awsAccessKeyId">AWS Access Key ID</param>
/// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
/// <param name="region">The region to connect.</param>
public AmazonVPCLatticeClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonVPCLatticeConfig() {RegionEndpoint=region})
{
}
/// <summary>
/// Constructs AmazonVPCLatticeClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonVPCLatticeClient Configuration object.
/// </summary>
/// <param name="awsAccessKeyId">AWS Access Key ID</param>
/// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
/// <param name="clientConfig">The AmazonVPCLatticeClient Configuration Object</param>
public AmazonVPCLatticeClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonVPCLatticeConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, clientConfig)
{
}
/// <summary>
/// Constructs AmazonVPCLatticeClient with AWS Access Key ID and AWS Secret Key
/// </summary>
/// <param name="awsAccessKeyId">AWS Access Key ID</param>
/// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
/// <param name="awsSessionToken">AWS Session Token</param>
public AmazonVPCLatticeClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonVPCLatticeConfig())
{
}
/// <summary>
/// Constructs AmazonVPCLatticeClient with AWS Access Key ID and AWS Secret Key
/// </summary>
/// <param name="awsAccessKeyId">AWS Access Key ID</param>
/// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
/// <param name="awsSessionToken">AWS Session Token</param>
/// <param name="region">The region to connect.</param>
public AmazonVPCLatticeClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonVPCLatticeConfig{RegionEndpoint = region})
{
}
/// <summary>
/// Constructs AmazonVPCLatticeClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonVPCLatticeClient Configuration object.
/// </summary>
/// <param name="awsAccessKeyId">AWS Access Key ID</param>
/// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
/// <param name="awsSessionToken">AWS Session Token</param>
/// <param name="clientConfig">The AmazonVPCLatticeClient Configuration Object</param>
public AmazonVPCLatticeClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonVPCLatticeConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig)
{
}
#endregion
#region Overrides
/// <summary>
/// Creates the signer for the service.
/// </summary>
protected override AbstractAWSSigner CreateSigner()
{
return new AWS4Signer();
}
/// <summary>
/// Customize the pipeline
/// </summary>
/// <param name="pipeline"></param>
protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline)
{
pipeline.RemoveHandler<Amazon.Runtime.Internal.EndpointResolver>();
pipeline.AddHandlerAfter<Amazon.Runtime.Internal.Marshaller>(new AmazonVPCLatticeEndpointResolver());
}
/// <summary>
/// Capture metadata for the service.
/// </summary>
protected override IServiceMetadata ServiceMetadata
{
get
{
return serviceMetadata;
}
}
#endregion
#region Dispose
/// <summary>
/// Disposes the service client.
/// </summary>
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
}
#endregion
#region BatchUpdateRule
/// <summary>
/// Updates the listener rules in a batch. You can use this operation to change the priority
/// of listener rules. This can be useful when bulk updating or swapping rule priority.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the BatchUpdateRule service method.</param>
///
/// <returns>The response from the BatchUpdateRule service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/BatchUpdateRule">REST API Reference for BatchUpdateRule Operation</seealso>
public virtual BatchUpdateRuleResponse BatchUpdateRule(BatchUpdateRuleRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = BatchUpdateRuleRequestMarshaller.Instance;
options.ResponseUnmarshaller = BatchUpdateRuleResponseUnmarshaller.Instance;
return Invoke<BatchUpdateRuleResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the BatchUpdateRule operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the BatchUpdateRule operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchUpdateRule
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/BatchUpdateRule">REST API Reference for BatchUpdateRule Operation</seealso>
public virtual IAsyncResult BeginBatchUpdateRule(BatchUpdateRuleRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = BatchUpdateRuleRequestMarshaller.Instance;
options.ResponseUnmarshaller = BatchUpdateRuleResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the BatchUpdateRule operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginBatchUpdateRule.</param>
///
/// <returns>Returns a BatchUpdateRuleResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/BatchUpdateRule">REST API Reference for BatchUpdateRule Operation</seealso>
public virtual BatchUpdateRuleResponse EndBatchUpdateRule(IAsyncResult asyncResult)
{
return EndInvoke<BatchUpdateRuleResponse>(asyncResult);
}
#endregion
#region CreateAccessLogSubscription
/// <summary>
/// Enables access logs to be sent to Amazon CloudWatch, Amazon S3, and Amazon Kinesis
/// Data Firehose. The service network owner can use the access logs to audit the services
/// in the network. The service network owner will only see access logs from clients and
/// services that are associated with their service network. Access log entries represent
/// traffic originated from VPCs associated with that network. For more information, see
/// <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/monitoring-access-logs.html">Access
/// logs</a> in the <i>Amazon VPC Lattice User Guide</i>.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateAccessLogSubscription service method.</param>
///
/// <returns>The response from the CreateAccessLogSubscription service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateAccessLogSubscription">REST API Reference for CreateAccessLogSubscription Operation</seealso>
public virtual CreateAccessLogSubscriptionResponse CreateAccessLogSubscription(CreateAccessLogSubscriptionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateAccessLogSubscriptionRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateAccessLogSubscriptionResponseUnmarshaller.Instance;
return Invoke<CreateAccessLogSubscriptionResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateAccessLogSubscription operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateAccessLogSubscription operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateAccessLogSubscription
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateAccessLogSubscription">REST API Reference for CreateAccessLogSubscription Operation</seealso>
public virtual IAsyncResult BeginCreateAccessLogSubscription(CreateAccessLogSubscriptionRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateAccessLogSubscriptionRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateAccessLogSubscriptionResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the CreateAccessLogSubscription operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateAccessLogSubscription.</param>
///
/// <returns>Returns a CreateAccessLogSubscriptionResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateAccessLogSubscription">REST API Reference for CreateAccessLogSubscription Operation</seealso>
public virtual CreateAccessLogSubscriptionResponse EndCreateAccessLogSubscription(IAsyncResult asyncResult)
{
return EndInvoke<CreateAccessLogSubscriptionResponse>(asyncResult);
}
#endregion
#region CreateListener
/// <summary>
/// Creates a listener for a service. Before you start using your Amazon VPC Lattice service,
/// you must add one or more listeners. A listener is a process that checks for connection
/// requests to your services. For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/listeners.html">Listeners</a>
/// in the <i>Amazon VPC Lattice User Guide</i>.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateListener service method.</param>
///
/// <returns>The response from the CreateListener service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ServiceQuotaExceededException">
/// The request would cause a service quota to be exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateListener">REST API Reference for CreateListener Operation</seealso>
public virtual CreateListenerResponse CreateListener(CreateListenerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateListenerRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateListenerResponseUnmarshaller.Instance;
return Invoke<CreateListenerResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateListener operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateListener operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateListener
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateListener">REST API Reference for CreateListener Operation</seealso>
public virtual IAsyncResult BeginCreateListener(CreateListenerRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateListenerRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateListenerResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the CreateListener operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateListener.</param>
///
/// <returns>Returns a CreateListenerResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateListener">REST API Reference for CreateListener Operation</seealso>
public virtual CreateListenerResponse EndCreateListener(IAsyncResult asyncResult)
{
return EndInvoke<CreateListenerResponse>(asyncResult);
}
#endregion
#region CreateRule
/// <summary>
/// Creates a listener rule. Each listener has a default rule for checking connection
/// requests, but you can define additional rules. Each rule consists of a priority, one
/// or more actions, and one or more conditions. For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/listeners.html#listener-rules">Listener
/// rules</a> in the <i>Amazon VPC Lattice User Guide</i>.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateRule service method.</param>
///
/// <returns>The response from the CreateRule service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ServiceQuotaExceededException">
/// The request would cause a service quota to be exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateRule">REST API Reference for CreateRule Operation</seealso>
public virtual CreateRuleResponse CreateRule(CreateRuleRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateRuleRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateRuleResponseUnmarshaller.Instance;
return Invoke<CreateRuleResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateRule operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateRule operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateRule
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateRule">REST API Reference for CreateRule Operation</seealso>
public virtual IAsyncResult BeginCreateRule(CreateRuleRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateRuleRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateRuleResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the CreateRule operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateRule.</param>
///
/// <returns>Returns a CreateRuleResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateRule">REST API Reference for CreateRule Operation</seealso>
public virtual CreateRuleResponse EndCreateRule(IAsyncResult asyncResult)
{
return EndInvoke<CreateRuleResponse>(asyncResult);
}
#endregion
#region CreateService
/// <summary>
/// Creates a service. A service is any software application that can run on instances
/// containers, or serverless functions within an account or virtual private cloud (VPC).
///
///
/// <para>
/// For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/services.html">Services</a>
/// in the <i>Amazon VPC Lattice User Guide</i>.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateService service method.</param>
///
/// <returns>The response from the CreateService service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ServiceQuotaExceededException">
/// The request would cause a service quota to be exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateService">REST API Reference for CreateService Operation</seealso>
public virtual CreateServiceResponse CreateService(CreateServiceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateServiceRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateServiceResponseUnmarshaller.Instance;
return Invoke<CreateServiceResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateService operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateService operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateService
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateService">REST API Reference for CreateService Operation</seealso>
public virtual IAsyncResult BeginCreateService(CreateServiceRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateServiceRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateServiceResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the CreateService operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateService.</param>
///
/// <returns>Returns a CreateServiceResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateService">REST API Reference for CreateService Operation</seealso>
public virtual CreateServiceResponse EndCreateService(IAsyncResult asyncResult)
{
return EndInvoke<CreateServiceResponse>(asyncResult);
}
#endregion
#region CreateServiceNetwork
/// <summary>
/// Creates a service network. A service network is a logical boundary for a collection
/// of services. You can associate services and VPCs with a service network.
///
///
/// <para>
/// For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/service-networks.html">Service
/// networks</a> in the <i>Amazon VPC Lattice User Guide</i>.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateServiceNetwork service method.</param>
///
/// <returns>The response from the CreateServiceNetwork service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ServiceQuotaExceededException">
/// The request would cause a service quota to be exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateServiceNetwork">REST API Reference for CreateServiceNetwork Operation</seealso>
public virtual CreateServiceNetworkResponse CreateServiceNetwork(CreateServiceNetworkRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateServiceNetworkRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateServiceNetworkResponseUnmarshaller.Instance;
return Invoke<CreateServiceNetworkResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateServiceNetwork operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateServiceNetwork operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateServiceNetwork
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateServiceNetwork">REST API Reference for CreateServiceNetwork Operation</seealso>
public virtual IAsyncResult BeginCreateServiceNetwork(CreateServiceNetworkRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateServiceNetworkRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateServiceNetworkResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the CreateServiceNetwork operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateServiceNetwork.</param>
///
/// <returns>Returns a CreateServiceNetworkResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateServiceNetwork">REST API Reference for CreateServiceNetwork Operation</seealso>
public virtual CreateServiceNetworkResponse EndCreateServiceNetwork(IAsyncResult asyncResult)
{
return EndInvoke<CreateServiceNetworkResponse>(asyncResult);
}
#endregion
#region CreateServiceNetworkServiceAssociation
/// <summary>
/// Associates a service with a service network.
///
///
/// <para>
/// You can't use this operation if the service and service network are already associated
/// or if there is a disassociation or deletion in progress. If the association fails,
/// you can retry the operation by deleting the association and recreating it.
/// </para>
///
/// <para>
/// You cannot associate a service and service network that are shared with a caller.
/// The caller must own either the service or the service network.
/// </para>
///
/// <para>
/// As a result of this operation, the association is created in the service network account
/// and the association owner account.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateServiceNetworkServiceAssociation service method.</param>
///
/// <returns>The response from the CreateServiceNetworkServiceAssociation service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ServiceQuotaExceededException">
/// The request would cause a service quota to be exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateServiceNetworkServiceAssociation">REST API Reference for CreateServiceNetworkServiceAssociation Operation</seealso>
public virtual CreateServiceNetworkServiceAssociationResponse CreateServiceNetworkServiceAssociation(CreateServiceNetworkServiceAssociationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateServiceNetworkServiceAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateServiceNetworkServiceAssociationResponseUnmarshaller.Instance;
return Invoke<CreateServiceNetworkServiceAssociationResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateServiceNetworkServiceAssociation operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateServiceNetworkServiceAssociation operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateServiceNetworkServiceAssociation
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateServiceNetworkServiceAssociation">REST API Reference for CreateServiceNetworkServiceAssociation Operation</seealso>
public virtual IAsyncResult BeginCreateServiceNetworkServiceAssociation(CreateServiceNetworkServiceAssociationRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateServiceNetworkServiceAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateServiceNetworkServiceAssociationResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the CreateServiceNetworkServiceAssociation operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateServiceNetworkServiceAssociation.</param>
///
/// <returns>Returns a CreateServiceNetworkServiceAssociationResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateServiceNetworkServiceAssociation">REST API Reference for CreateServiceNetworkServiceAssociation Operation</seealso>
public virtual CreateServiceNetworkServiceAssociationResponse EndCreateServiceNetworkServiceAssociation(IAsyncResult asyncResult)
{
return EndInvoke<CreateServiceNetworkServiceAssociationResponse>(asyncResult);
}
#endregion
#region CreateServiceNetworkVpcAssociation
/// <summary>
/// Associates a VPC with a service network. When you associate a VPC with the service
/// network, it enables all the resources within that VPC to be clients and communicate
/// with other services in the service network. For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/service-network-associations.html#service-network-vpc-associations">Manage
/// VPC associations</a> in the <i>Amazon VPC Lattice User Guide</i>.
///
///
/// <para>
/// You can't use this operation if there is a disassociation in progress. If the association
/// fails, retry by deleting the association and recreating it.
/// </para>
///
/// <para>
/// As a result of this operation, the association gets created in the service network
/// account and the VPC owner account.
/// </para>
///
/// <para>
/// If you add a security group to the service network and VPC association, the association
/// must continue to always have at least one security group. You can add or edit security
/// groups at any time. However, to remove all security groups, you must first delete
/// the association and recreate it without security groups.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateServiceNetworkVpcAssociation service method.</param>
///
/// <returns>The response from the CreateServiceNetworkVpcAssociation service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ServiceQuotaExceededException">
/// The request would cause a service quota to be exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateServiceNetworkVpcAssociation">REST API Reference for CreateServiceNetworkVpcAssociation Operation</seealso>
public virtual CreateServiceNetworkVpcAssociationResponse CreateServiceNetworkVpcAssociation(CreateServiceNetworkVpcAssociationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateServiceNetworkVpcAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateServiceNetworkVpcAssociationResponseUnmarshaller.Instance;
return Invoke<CreateServiceNetworkVpcAssociationResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateServiceNetworkVpcAssociation operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateServiceNetworkVpcAssociation operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateServiceNetworkVpcAssociation
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateServiceNetworkVpcAssociation">REST API Reference for CreateServiceNetworkVpcAssociation Operation</seealso>
public virtual IAsyncResult BeginCreateServiceNetworkVpcAssociation(CreateServiceNetworkVpcAssociationRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateServiceNetworkVpcAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateServiceNetworkVpcAssociationResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the CreateServiceNetworkVpcAssociation operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateServiceNetworkVpcAssociation.</param>
///
/// <returns>Returns a CreateServiceNetworkVpcAssociationResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateServiceNetworkVpcAssociation">REST API Reference for CreateServiceNetworkVpcAssociation Operation</seealso>
public virtual CreateServiceNetworkVpcAssociationResponse EndCreateServiceNetworkVpcAssociation(IAsyncResult asyncResult)
{
return EndInvoke<CreateServiceNetworkVpcAssociationResponse>(asyncResult);
}
#endregion
#region CreateTargetGroup
/// <summary>
/// Creates a target group. A target group is a collection of targets, or compute resources,
/// that run your application or service. A target group can only be used by a single
/// service.
///
///
/// <para>
/// For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/target-groups.html">Target
/// groups</a> in the <i>Amazon VPC Lattice User Guide</i>.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateTargetGroup service method.</param>
///
/// <returns>The response from the CreateTargetGroup service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ServiceQuotaExceededException">
/// The request would cause a service quota to be exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateTargetGroup">REST API Reference for CreateTargetGroup Operation</seealso>
public virtual CreateTargetGroupResponse CreateTargetGroup(CreateTargetGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateTargetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateTargetGroupResponseUnmarshaller.Instance;
return Invoke<CreateTargetGroupResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateTargetGroup operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateTargetGroup operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTargetGroup
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateTargetGroup">REST API Reference for CreateTargetGroup Operation</seealso>
public virtual IAsyncResult BeginCreateTargetGroup(CreateTargetGroupRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateTargetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateTargetGroupResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the CreateTargetGroup operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTargetGroup.</param>
///
/// <returns>Returns a CreateTargetGroupResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/CreateTargetGroup">REST API Reference for CreateTargetGroup Operation</seealso>
public virtual CreateTargetGroupResponse EndCreateTargetGroup(IAsyncResult asyncResult)
{
return EndInvoke<CreateTargetGroupResponse>(asyncResult);
}
#endregion
#region DeleteAccessLogSubscription
/// <summary>
/// Deletes the specified access log subscription.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteAccessLogSubscription service method.</param>
///
/// <returns>The response from the DeleteAccessLogSubscription service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteAccessLogSubscription">REST API Reference for DeleteAccessLogSubscription Operation</seealso>
public virtual DeleteAccessLogSubscriptionResponse DeleteAccessLogSubscription(DeleteAccessLogSubscriptionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteAccessLogSubscriptionRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteAccessLogSubscriptionResponseUnmarshaller.Instance;
return Invoke<DeleteAccessLogSubscriptionResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteAccessLogSubscription operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteAccessLogSubscription operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteAccessLogSubscription
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteAccessLogSubscription">REST API Reference for DeleteAccessLogSubscription Operation</seealso>
public virtual IAsyncResult BeginDeleteAccessLogSubscription(DeleteAccessLogSubscriptionRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteAccessLogSubscriptionRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteAccessLogSubscriptionResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the DeleteAccessLogSubscription operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteAccessLogSubscription.</param>
///
/// <returns>Returns a DeleteAccessLogSubscriptionResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteAccessLogSubscription">REST API Reference for DeleteAccessLogSubscription Operation</seealso>
public virtual DeleteAccessLogSubscriptionResponse EndDeleteAccessLogSubscription(IAsyncResult asyncResult)
{
return EndInvoke<DeleteAccessLogSubscriptionResponse>(asyncResult);
}
#endregion
#region DeleteAuthPolicy
/// <summary>
/// Deletes the specified auth policy. If an auth is set to <code>AWS_IAM</code> and the
/// auth policy is deleted, all requests will be denied by default. If you are trying
/// to remove the auth policy completely, you must set the auth_type to <code>NONE</code>.
/// If auth is enabled on the resource, but no auth policy is set, all requests will be
/// denied.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteAuthPolicy service method.</param>
///
/// <returns>The response from the DeleteAuthPolicy service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteAuthPolicy">REST API Reference for DeleteAuthPolicy Operation</seealso>
public virtual DeleteAuthPolicyResponse DeleteAuthPolicy(DeleteAuthPolicyRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteAuthPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteAuthPolicyResponseUnmarshaller.Instance;
return Invoke<DeleteAuthPolicyResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteAuthPolicy operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteAuthPolicy operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteAuthPolicy
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteAuthPolicy">REST API Reference for DeleteAuthPolicy Operation</seealso>
public virtual IAsyncResult BeginDeleteAuthPolicy(DeleteAuthPolicyRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteAuthPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteAuthPolicyResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the DeleteAuthPolicy operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteAuthPolicy.</param>
///
/// <returns>Returns a DeleteAuthPolicyResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteAuthPolicy">REST API Reference for DeleteAuthPolicy Operation</seealso>
public virtual DeleteAuthPolicyResponse EndDeleteAuthPolicy(IAsyncResult asyncResult)
{
return EndInvoke<DeleteAuthPolicyResponse>(asyncResult);
}
#endregion
#region DeleteListener
/// <summary>
/// Deletes the specified listener.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteListener service method.</param>
///
/// <returns>The response from the DeleteListener service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteListener">REST API Reference for DeleteListener Operation</seealso>
public virtual DeleteListenerResponse DeleteListener(DeleteListenerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteListenerRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteListenerResponseUnmarshaller.Instance;
return Invoke<DeleteListenerResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteListener operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteListener operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteListener
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteListener">REST API Reference for DeleteListener Operation</seealso>
public virtual IAsyncResult BeginDeleteListener(DeleteListenerRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteListenerRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteListenerResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the DeleteListener operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteListener.</param>
///
/// <returns>Returns a DeleteListenerResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteListener">REST API Reference for DeleteListener Operation</seealso>
public virtual DeleteListenerResponse EndDeleteListener(IAsyncResult asyncResult)
{
return EndInvoke<DeleteListenerResponse>(asyncResult);
}
#endregion
#region DeleteResourcePolicy
/// <summary>
/// Deletes the specified resource policy.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteResourcePolicy service method.</param>
///
/// <returns>The response from the DeleteResourcePolicy service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteResourcePolicy">REST API Reference for DeleteResourcePolicy Operation</seealso>
public virtual DeleteResourcePolicyResponse DeleteResourcePolicy(DeleteResourcePolicyRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance;
return Invoke<DeleteResourcePolicyResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteResourcePolicy operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteResourcePolicy operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteResourcePolicy
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteResourcePolicy">REST API Reference for DeleteResourcePolicy Operation</seealso>
public virtual IAsyncResult BeginDeleteResourcePolicy(DeleteResourcePolicyRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the DeleteResourcePolicy operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteResourcePolicy.</param>
///
/// <returns>Returns a DeleteResourcePolicyResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteResourcePolicy">REST API Reference for DeleteResourcePolicy Operation</seealso>
public virtual DeleteResourcePolicyResponse EndDeleteResourcePolicy(IAsyncResult asyncResult)
{
return EndInvoke<DeleteResourcePolicyResponse>(asyncResult);
}
#endregion
#region DeleteRule
/// <summary>
/// Deletes a listener rule. Each listener has a default rule for checking connection
/// requests, but you can define additional rules. Each rule consists of a priority, one
/// or more actions, and one or more conditions. You can delete additional listener rules,
/// but you cannot delete the default rule.
///
///
/// <para>
/// For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/listeners.html#listener-rules">Listener
/// rules</a> in the <i>Amazon VPC Lattice User Guide</i>.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteRule service method.</param>
///
/// <returns>The response from the DeleteRule service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteRule">REST API Reference for DeleteRule Operation</seealso>
public virtual DeleteRuleResponse DeleteRule(DeleteRuleRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteRuleRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteRuleResponseUnmarshaller.Instance;
return Invoke<DeleteRuleResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteRule operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteRule operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteRule
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteRule">REST API Reference for DeleteRule Operation</seealso>
public virtual IAsyncResult BeginDeleteRule(DeleteRuleRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteRuleRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteRuleResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the DeleteRule operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteRule.</param>
///
/// <returns>Returns a DeleteRuleResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteRule">REST API Reference for DeleteRule Operation</seealso>
public virtual DeleteRuleResponse EndDeleteRule(IAsyncResult asyncResult)
{
return EndInvoke<DeleteRuleResponse>(asyncResult);
}
#endregion
#region DeleteService
/// <summary>
/// Deletes a service. A service can't be deleted if it's associated with a service network.
/// If you delete a service, all resources related to the service, such as the resource
/// policy, auth policy, listeners, listener rules, and access log subscriptions, are
/// also deleted. For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/services.html#delete-service">Delete
/// a service</a> in the <i>Amazon VPC Lattice User Guide</i>.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteService service method.</param>
///
/// <returns>The response from the DeleteService service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteService">REST API Reference for DeleteService Operation</seealso>
public virtual DeleteServiceResponse DeleteService(DeleteServiceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteServiceRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteServiceResponseUnmarshaller.Instance;
return Invoke<DeleteServiceResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteService operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteService operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteService
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteService">REST API Reference for DeleteService Operation</seealso>
public virtual IAsyncResult BeginDeleteService(DeleteServiceRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteServiceRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteServiceResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the DeleteService operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteService.</param>
///
/// <returns>Returns a DeleteServiceResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteService">REST API Reference for DeleteService Operation</seealso>
public virtual DeleteServiceResponse EndDeleteService(IAsyncResult asyncResult)
{
return EndInvoke<DeleteServiceResponse>(asyncResult);
}
#endregion
#region DeleteServiceNetwork
/// <summary>
/// Deletes a service network. You can only delete the service network if there is no
/// service or VPC associated with it. If you delete a service network, all resources
/// related to the service network, such as the resource policy, auth policy, and access
/// log subscriptions, are also deleted. For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/service-networks.html#delete-service-network">Delete
/// a service network</a> in the <i>Amazon VPC Lattice User Guide</i>.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteServiceNetwork service method.</param>
///
/// <returns>The response from the DeleteServiceNetwork service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteServiceNetwork">REST API Reference for DeleteServiceNetwork Operation</seealso>
public virtual DeleteServiceNetworkResponse DeleteServiceNetwork(DeleteServiceNetworkRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteServiceNetworkRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteServiceNetworkResponseUnmarshaller.Instance;
return Invoke<DeleteServiceNetworkResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteServiceNetwork operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteServiceNetwork operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteServiceNetwork
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteServiceNetwork">REST API Reference for DeleteServiceNetwork Operation</seealso>
public virtual IAsyncResult BeginDeleteServiceNetwork(DeleteServiceNetworkRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteServiceNetworkRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteServiceNetworkResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the DeleteServiceNetwork operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteServiceNetwork.</param>
///
/// <returns>Returns a DeleteServiceNetworkResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteServiceNetwork">REST API Reference for DeleteServiceNetwork Operation</seealso>
public virtual DeleteServiceNetworkResponse EndDeleteServiceNetwork(IAsyncResult asyncResult)
{
return EndInvoke<DeleteServiceNetworkResponse>(asyncResult);
}
#endregion
#region DeleteServiceNetworkServiceAssociation
/// <summary>
/// Deletes the association between a specified service and the specific service network.
/// This request will fail if an association is still in progress.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteServiceNetworkServiceAssociation service method.</param>
///
/// <returns>The response from the DeleteServiceNetworkServiceAssociation service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteServiceNetworkServiceAssociation">REST API Reference for DeleteServiceNetworkServiceAssociation Operation</seealso>
public virtual DeleteServiceNetworkServiceAssociationResponse DeleteServiceNetworkServiceAssociation(DeleteServiceNetworkServiceAssociationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteServiceNetworkServiceAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteServiceNetworkServiceAssociationResponseUnmarshaller.Instance;
return Invoke<DeleteServiceNetworkServiceAssociationResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteServiceNetworkServiceAssociation operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteServiceNetworkServiceAssociation operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteServiceNetworkServiceAssociation
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteServiceNetworkServiceAssociation">REST API Reference for DeleteServiceNetworkServiceAssociation Operation</seealso>
public virtual IAsyncResult BeginDeleteServiceNetworkServiceAssociation(DeleteServiceNetworkServiceAssociationRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteServiceNetworkServiceAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteServiceNetworkServiceAssociationResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the DeleteServiceNetworkServiceAssociation operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteServiceNetworkServiceAssociation.</param>
///
/// <returns>Returns a DeleteServiceNetworkServiceAssociationResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteServiceNetworkServiceAssociation">REST API Reference for DeleteServiceNetworkServiceAssociation Operation</seealso>
public virtual DeleteServiceNetworkServiceAssociationResponse EndDeleteServiceNetworkServiceAssociation(IAsyncResult asyncResult)
{
return EndInvoke<DeleteServiceNetworkServiceAssociationResponse>(asyncResult);
}
#endregion
#region DeleteServiceNetworkVpcAssociation
/// <summary>
/// Disassociates the VPC from the service network. You can't disassociate the VPC if
/// there is a create or update association in progress.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteServiceNetworkVpcAssociation service method.</param>
///
/// <returns>The response from the DeleteServiceNetworkVpcAssociation service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteServiceNetworkVpcAssociation">REST API Reference for DeleteServiceNetworkVpcAssociation Operation</seealso>
public virtual DeleteServiceNetworkVpcAssociationResponse DeleteServiceNetworkVpcAssociation(DeleteServiceNetworkVpcAssociationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteServiceNetworkVpcAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteServiceNetworkVpcAssociationResponseUnmarshaller.Instance;
return Invoke<DeleteServiceNetworkVpcAssociationResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteServiceNetworkVpcAssociation operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteServiceNetworkVpcAssociation operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteServiceNetworkVpcAssociation
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteServiceNetworkVpcAssociation">REST API Reference for DeleteServiceNetworkVpcAssociation Operation</seealso>
public virtual IAsyncResult BeginDeleteServiceNetworkVpcAssociation(DeleteServiceNetworkVpcAssociationRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteServiceNetworkVpcAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteServiceNetworkVpcAssociationResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the DeleteServiceNetworkVpcAssociation operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteServiceNetworkVpcAssociation.</param>
///
/// <returns>Returns a DeleteServiceNetworkVpcAssociationResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteServiceNetworkVpcAssociation">REST API Reference for DeleteServiceNetworkVpcAssociation Operation</seealso>
public virtual DeleteServiceNetworkVpcAssociationResponse EndDeleteServiceNetworkVpcAssociation(IAsyncResult asyncResult)
{
return EndInvoke<DeleteServiceNetworkVpcAssociationResponse>(asyncResult);
}
#endregion
#region DeleteTargetGroup
/// <summary>
/// Deletes a target group. You can't delete a target group if it is used in a listener
/// rule or if the target group creation is in progress.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteTargetGroup service method.</param>
///
/// <returns>The response from the DeleteTargetGroup service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteTargetGroup">REST API Reference for DeleteTargetGroup Operation</seealso>
public virtual DeleteTargetGroupResponse DeleteTargetGroup(DeleteTargetGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteTargetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteTargetGroupResponseUnmarshaller.Instance;
return Invoke<DeleteTargetGroupResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteTargetGroup operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteTargetGroup operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTargetGroup
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteTargetGroup">REST API Reference for DeleteTargetGroup Operation</seealso>
public virtual IAsyncResult BeginDeleteTargetGroup(DeleteTargetGroupRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteTargetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteTargetGroupResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the DeleteTargetGroup operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTargetGroup.</param>
///
/// <returns>Returns a DeleteTargetGroupResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeleteTargetGroup">REST API Reference for DeleteTargetGroup Operation</seealso>
public virtual DeleteTargetGroupResponse EndDeleteTargetGroup(IAsyncResult asyncResult)
{
return EndInvoke<DeleteTargetGroupResponse>(asyncResult);
}
#endregion
#region DeregisterTargets
/// <summary>
/// Deregisters the specified targets from the specified target group.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeregisterTargets service method.</param>
///
/// <returns>The response from the DeregisterTargets service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeregisterTargets">REST API Reference for DeregisterTargets Operation</seealso>
public virtual DeregisterTargetsResponse DeregisterTargets(DeregisterTargetsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeregisterTargetsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeregisterTargetsResponseUnmarshaller.Instance;
return Invoke<DeregisterTargetsResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the DeregisterTargets operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeregisterTargets operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterTargets
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeregisterTargets">REST API Reference for DeregisterTargets Operation</seealso>
public virtual IAsyncResult BeginDeregisterTargets(DeregisterTargetsRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeregisterTargetsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeregisterTargetsResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the DeregisterTargets operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeregisterTargets.</param>
///
/// <returns>Returns a DeregisterTargetsResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/DeregisterTargets">REST API Reference for DeregisterTargets Operation</seealso>
public virtual DeregisterTargetsResponse EndDeregisterTargets(IAsyncResult asyncResult)
{
return EndInvoke<DeregisterTargetsResponse>(asyncResult);
}
#endregion
#region GetAccessLogSubscription
/// <summary>
/// Retrieves information about the specified access log subscription.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetAccessLogSubscription service method.</param>
///
/// <returns>The response from the GetAccessLogSubscription service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetAccessLogSubscription">REST API Reference for GetAccessLogSubscription Operation</seealso>
public virtual GetAccessLogSubscriptionResponse GetAccessLogSubscription(GetAccessLogSubscriptionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetAccessLogSubscriptionRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetAccessLogSubscriptionResponseUnmarshaller.Instance;
return Invoke<GetAccessLogSubscriptionResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetAccessLogSubscription operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetAccessLogSubscription operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAccessLogSubscription
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetAccessLogSubscription">REST API Reference for GetAccessLogSubscription Operation</seealso>
public virtual IAsyncResult BeginGetAccessLogSubscription(GetAccessLogSubscriptionRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetAccessLogSubscriptionRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetAccessLogSubscriptionResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the GetAccessLogSubscription operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetAccessLogSubscription.</param>
///
/// <returns>Returns a GetAccessLogSubscriptionResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetAccessLogSubscription">REST API Reference for GetAccessLogSubscription Operation</seealso>
public virtual GetAccessLogSubscriptionResponse EndGetAccessLogSubscription(IAsyncResult asyncResult)
{
return EndInvoke<GetAccessLogSubscriptionResponse>(asyncResult);
}
#endregion
#region GetAuthPolicy
/// <summary>
/// Retrieves information about the auth policy for the specified service or service network.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetAuthPolicy service method.</param>
///
/// <returns>The response from the GetAuthPolicy service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetAuthPolicy">REST API Reference for GetAuthPolicy Operation</seealso>
public virtual GetAuthPolicyResponse GetAuthPolicy(GetAuthPolicyRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetAuthPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetAuthPolicyResponseUnmarshaller.Instance;
return Invoke<GetAuthPolicyResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetAuthPolicy operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetAuthPolicy operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAuthPolicy
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetAuthPolicy">REST API Reference for GetAuthPolicy Operation</seealso>
public virtual IAsyncResult BeginGetAuthPolicy(GetAuthPolicyRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetAuthPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetAuthPolicyResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the GetAuthPolicy operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetAuthPolicy.</param>
///
/// <returns>Returns a GetAuthPolicyResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetAuthPolicy">REST API Reference for GetAuthPolicy Operation</seealso>
public virtual GetAuthPolicyResponse EndGetAuthPolicy(IAsyncResult asyncResult)
{
return EndInvoke<GetAuthPolicyResponse>(asyncResult);
}
#endregion
#region GetListener
/// <summary>
/// Retrieves information about the specified listener for the specified service.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetListener service method.</param>
///
/// <returns>The response from the GetListener service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetListener">REST API Reference for GetListener Operation</seealso>
public virtual GetListenerResponse GetListener(GetListenerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetListenerRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetListenerResponseUnmarshaller.Instance;
return Invoke<GetListenerResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetListener operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetListener operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetListener
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetListener">REST API Reference for GetListener Operation</seealso>
public virtual IAsyncResult BeginGetListener(GetListenerRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetListenerRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetListenerResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the GetListener operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetListener.</param>
///
/// <returns>Returns a GetListenerResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetListener">REST API Reference for GetListener Operation</seealso>
public virtual GetListenerResponse EndGetListener(IAsyncResult asyncResult)
{
return EndInvoke<GetListenerResponse>(asyncResult);
}
#endregion
#region GetResourcePolicy
/// <summary>
/// Retrieves information about the resource policy. The resource policy is an IAM policy
/// created on behalf of the resource owner when they share a resource.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetResourcePolicy service method.</param>
///
/// <returns>The response from the GetResourcePolicy service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetResourcePolicy">REST API Reference for GetResourcePolicy Operation</seealso>
public virtual GetResourcePolicyResponse GetResourcePolicy(GetResourcePolicyRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetResourcePolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetResourcePolicyResponseUnmarshaller.Instance;
return Invoke<GetResourcePolicyResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetResourcePolicy operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetResourcePolicy operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetResourcePolicy
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetResourcePolicy">REST API Reference for GetResourcePolicy Operation</seealso>
public virtual IAsyncResult BeginGetResourcePolicy(GetResourcePolicyRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetResourcePolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetResourcePolicyResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the GetResourcePolicy operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetResourcePolicy.</param>
///
/// <returns>Returns a GetResourcePolicyResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetResourcePolicy">REST API Reference for GetResourcePolicy Operation</seealso>
public virtual GetResourcePolicyResponse EndGetResourcePolicy(IAsyncResult asyncResult)
{
return EndInvoke<GetResourcePolicyResponse>(asyncResult);
}
#endregion
#region GetRule
/// <summary>
/// Retrieves information about listener rules. You can also retrieve information about
/// the default listener rule. For more information, see <a href="https://docs.aws.amazon.com/vpc-lattice/latest/ug/listeners.html#listener-rules">Listener
/// rules</a> in the <i>Amazon VPC Lattice User Guide</i>.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetRule service method.</param>
///
/// <returns>The response from the GetRule service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetRule">REST API Reference for GetRule Operation</seealso>
public virtual GetRuleResponse GetRule(GetRuleRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetRuleRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetRuleResponseUnmarshaller.Instance;
return Invoke<GetRuleResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetRule operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetRule operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRule
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetRule">REST API Reference for GetRule Operation</seealso>
public virtual IAsyncResult BeginGetRule(GetRuleRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetRuleRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetRuleResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the GetRule operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetRule.</param>
///
/// <returns>Returns a GetRuleResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetRule">REST API Reference for GetRule Operation</seealso>
public virtual GetRuleResponse EndGetRule(IAsyncResult asyncResult)
{
return EndInvoke<GetRuleResponse>(asyncResult);
}
#endregion
#region GetService
/// <summary>
/// Retrieves information about the specified service.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetService service method.</param>
///
/// <returns>The response from the GetService service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetService">REST API Reference for GetService Operation</seealso>
public virtual GetServiceResponse GetService(GetServiceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetServiceRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetServiceResponseUnmarshaller.Instance;
return Invoke<GetServiceResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetService operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetService operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetService
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetService">REST API Reference for GetService Operation</seealso>
public virtual IAsyncResult BeginGetService(GetServiceRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetServiceRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetServiceResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the GetService operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetService.</param>
///
/// <returns>Returns a GetServiceResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetService">REST API Reference for GetService Operation</seealso>
public virtual GetServiceResponse EndGetService(IAsyncResult asyncResult)
{
return EndInvoke<GetServiceResponse>(asyncResult);
}
#endregion
#region GetServiceNetwork
/// <summary>
/// Retrieves information about the specified service network.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetServiceNetwork service method.</param>
///
/// <returns>The response from the GetServiceNetwork service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetServiceNetwork">REST API Reference for GetServiceNetwork Operation</seealso>
public virtual GetServiceNetworkResponse GetServiceNetwork(GetServiceNetworkRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetServiceNetworkRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetServiceNetworkResponseUnmarshaller.Instance;
return Invoke<GetServiceNetworkResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetServiceNetwork operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetServiceNetwork operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetServiceNetwork
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetServiceNetwork">REST API Reference for GetServiceNetwork Operation</seealso>
public virtual IAsyncResult BeginGetServiceNetwork(GetServiceNetworkRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetServiceNetworkRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetServiceNetworkResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the GetServiceNetwork operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetServiceNetwork.</param>
///
/// <returns>Returns a GetServiceNetworkResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetServiceNetwork">REST API Reference for GetServiceNetwork Operation</seealso>
public virtual GetServiceNetworkResponse EndGetServiceNetwork(IAsyncResult asyncResult)
{
return EndInvoke<GetServiceNetworkResponse>(asyncResult);
}
#endregion
#region GetServiceNetworkServiceAssociation
/// <summary>
/// Retrieves information about the specified association between a service network and
/// a service.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetServiceNetworkServiceAssociation service method.</param>
///
/// <returns>The response from the GetServiceNetworkServiceAssociation service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetServiceNetworkServiceAssociation">REST API Reference for GetServiceNetworkServiceAssociation Operation</seealso>
public virtual GetServiceNetworkServiceAssociationResponse GetServiceNetworkServiceAssociation(GetServiceNetworkServiceAssociationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetServiceNetworkServiceAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetServiceNetworkServiceAssociationResponseUnmarshaller.Instance;
return Invoke<GetServiceNetworkServiceAssociationResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetServiceNetworkServiceAssociation operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetServiceNetworkServiceAssociation operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetServiceNetworkServiceAssociation
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetServiceNetworkServiceAssociation">REST API Reference for GetServiceNetworkServiceAssociation Operation</seealso>
public virtual IAsyncResult BeginGetServiceNetworkServiceAssociation(GetServiceNetworkServiceAssociationRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetServiceNetworkServiceAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetServiceNetworkServiceAssociationResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the GetServiceNetworkServiceAssociation operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetServiceNetworkServiceAssociation.</param>
///
/// <returns>Returns a GetServiceNetworkServiceAssociationResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetServiceNetworkServiceAssociation">REST API Reference for GetServiceNetworkServiceAssociation Operation</seealso>
public virtual GetServiceNetworkServiceAssociationResponse EndGetServiceNetworkServiceAssociation(IAsyncResult asyncResult)
{
return EndInvoke<GetServiceNetworkServiceAssociationResponse>(asyncResult);
}
#endregion
#region GetServiceNetworkVpcAssociation
/// <summary>
/// Retrieves information about the association between a service network and a VPC.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetServiceNetworkVpcAssociation service method.</param>
///
/// <returns>The response from the GetServiceNetworkVpcAssociation service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetServiceNetworkVpcAssociation">REST API Reference for GetServiceNetworkVpcAssociation Operation</seealso>
public virtual GetServiceNetworkVpcAssociationResponse GetServiceNetworkVpcAssociation(GetServiceNetworkVpcAssociationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetServiceNetworkVpcAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetServiceNetworkVpcAssociationResponseUnmarshaller.Instance;
return Invoke<GetServiceNetworkVpcAssociationResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetServiceNetworkVpcAssociation operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetServiceNetworkVpcAssociation operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetServiceNetworkVpcAssociation
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetServiceNetworkVpcAssociation">REST API Reference for GetServiceNetworkVpcAssociation Operation</seealso>
public virtual IAsyncResult BeginGetServiceNetworkVpcAssociation(GetServiceNetworkVpcAssociationRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetServiceNetworkVpcAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetServiceNetworkVpcAssociationResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the GetServiceNetworkVpcAssociation operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetServiceNetworkVpcAssociation.</param>
///
/// <returns>Returns a GetServiceNetworkVpcAssociationResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetServiceNetworkVpcAssociation">REST API Reference for GetServiceNetworkVpcAssociation Operation</seealso>
public virtual GetServiceNetworkVpcAssociationResponse EndGetServiceNetworkVpcAssociation(IAsyncResult asyncResult)
{
return EndInvoke<GetServiceNetworkVpcAssociationResponse>(asyncResult);
}
#endregion
#region GetTargetGroup
/// <summary>
/// Retrieves information about the specified target group.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetTargetGroup service method.</param>
///
/// <returns>The response from the GetTargetGroup service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetTargetGroup">REST API Reference for GetTargetGroup Operation</seealso>
public virtual GetTargetGroupResponse GetTargetGroup(GetTargetGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetTargetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetTargetGroupResponseUnmarshaller.Instance;
return Invoke<GetTargetGroupResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetTargetGroup operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetTargetGroup operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTargetGroup
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetTargetGroup">REST API Reference for GetTargetGroup Operation</seealso>
public virtual IAsyncResult BeginGetTargetGroup(GetTargetGroupRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetTargetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetTargetGroupResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the GetTargetGroup operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetTargetGroup.</param>
///
/// <returns>Returns a GetTargetGroupResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/GetTargetGroup">REST API Reference for GetTargetGroup Operation</seealso>
public virtual GetTargetGroupResponse EndGetTargetGroup(IAsyncResult asyncResult)
{
return EndInvoke<GetTargetGroupResponse>(asyncResult);
}
#endregion
#region ListAccessLogSubscriptions
/// <summary>
/// Lists all access log subscriptions for the specified service network or service.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListAccessLogSubscriptions service method.</param>
///
/// <returns>The response from the ListAccessLogSubscriptions service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListAccessLogSubscriptions">REST API Reference for ListAccessLogSubscriptions Operation</seealso>
public virtual ListAccessLogSubscriptionsResponse ListAccessLogSubscriptions(ListAccessLogSubscriptionsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListAccessLogSubscriptionsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListAccessLogSubscriptionsResponseUnmarshaller.Instance;
return Invoke<ListAccessLogSubscriptionsResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListAccessLogSubscriptions operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListAccessLogSubscriptions operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListAccessLogSubscriptions
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListAccessLogSubscriptions">REST API Reference for ListAccessLogSubscriptions Operation</seealso>
public virtual IAsyncResult BeginListAccessLogSubscriptions(ListAccessLogSubscriptionsRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListAccessLogSubscriptionsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListAccessLogSubscriptionsResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the ListAccessLogSubscriptions operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginListAccessLogSubscriptions.</param>
///
/// <returns>Returns a ListAccessLogSubscriptionsResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListAccessLogSubscriptions">REST API Reference for ListAccessLogSubscriptions Operation</seealso>
public virtual ListAccessLogSubscriptionsResponse EndListAccessLogSubscriptions(IAsyncResult asyncResult)
{
return EndInvoke<ListAccessLogSubscriptionsResponse>(asyncResult);
}
#endregion
#region ListListeners
/// <summary>
/// Lists the listeners for the specified service.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListListeners service method.</param>
///
/// <returns>The response from the ListListeners service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListListeners">REST API Reference for ListListeners Operation</seealso>
public virtual ListListenersResponse ListListeners(ListListenersRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListListenersRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListListenersResponseUnmarshaller.Instance;
return Invoke<ListListenersResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListListeners operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListListeners operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListListeners
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListListeners">REST API Reference for ListListeners Operation</seealso>
public virtual IAsyncResult BeginListListeners(ListListenersRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListListenersRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListListenersResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the ListListeners operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginListListeners.</param>
///
/// <returns>Returns a ListListenersResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListListeners">REST API Reference for ListListeners Operation</seealso>
public virtual ListListenersResponse EndListListeners(IAsyncResult asyncResult)
{
return EndInvoke<ListListenersResponse>(asyncResult);
}
#endregion
#region ListRules
/// <summary>
/// Lists the rules for the listener.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListRules service method.</param>
///
/// <returns>The response from the ListRules service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListRules">REST API Reference for ListRules Operation</seealso>
public virtual ListRulesResponse ListRules(ListRulesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListRulesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListRulesResponseUnmarshaller.Instance;
return Invoke<ListRulesResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListRules operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListRules operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListRules
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListRules">REST API Reference for ListRules Operation</seealso>
public virtual IAsyncResult BeginListRules(ListRulesRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListRulesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListRulesResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the ListRules operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginListRules.</param>
///
/// <returns>Returns a ListRulesResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListRules">REST API Reference for ListRules Operation</seealso>
public virtual ListRulesResponse EndListRules(IAsyncResult asyncResult)
{
return EndInvoke<ListRulesResponse>(asyncResult);
}
#endregion
#region ListServiceNetworks
/// <summary>
/// Lists the service networks owned by the caller account or shared with the caller account.
/// Also includes the account ID in the ARN to show which account owns the service network.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListServiceNetworks service method.</param>
///
/// <returns>The response from the ListServiceNetworks service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServiceNetworks">REST API Reference for ListServiceNetworks Operation</seealso>
public virtual ListServiceNetworksResponse ListServiceNetworks(ListServiceNetworksRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListServiceNetworksRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListServiceNetworksResponseUnmarshaller.Instance;
return Invoke<ListServiceNetworksResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListServiceNetworks operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListServiceNetworks operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListServiceNetworks
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServiceNetworks">REST API Reference for ListServiceNetworks Operation</seealso>
public virtual IAsyncResult BeginListServiceNetworks(ListServiceNetworksRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListServiceNetworksRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListServiceNetworksResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the ListServiceNetworks operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginListServiceNetworks.</param>
///
/// <returns>Returns a ListServiceNetworksResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServiceNetworks">REST API Reference for ListServiceNetworks Operation</seealso>
public virtual ListServiceNetworksResponse EndListServiceNetworks(IAsyncResult asyncResult)
{
return EndInvoke<ListServiceNetworksResponse>(asyncResult);
}
#endregion
#region ListServiceNetworkServiceAssociations
/// <summary>
/// Lists the associations between the service network and the service. You can filter
/// the list either by service or service network. You must provide either the service
/// network identifier or the service identifier.
///
///
/// <para>
/// Every association in Amazon VPC Lattice is given a unique Amazon Resource Name (ARN),
/// such as when a service network is associated with a VPC or when a service is associated
/// with a service network. If the association is for a resource that is shared with another
/// account, the association will include the local account ID as the prefix in the ARN
/// for each account the resource is shared with.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListServiceNetworkServiceAssociations service method.</param>
///
/// <returns>The response from the ListServiceNetworkServiceAssociations service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServiceNetworkServiceAssociations">REST API Reference for ListServiceNetworkServiceAssociations Operation</seealso>
public virtual ListServiceNetworkServiceAssociationsResponse ListServiceNetworkServiceAssociations(ListServiceNetworkServiceAssociationsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListServiceNetworkServiceAssociationsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListServiceNetworkServiceAssociationsResponseUnmarshaller.Instance;
return Invoke<ListServiceNetworkServiceAssociationsResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListServiceNetworkServiceAssociations operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListServiceNetworkServiceAssociations operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListServiceNetworkServiceAssociations
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServiceNetworkServiceAssociations">REST API Reference for ListServiceNetworkServiceAssociations Operation</seealso>
public virtual IAsyncResult BeginListServiceNetworkServiceAssociations(ListServiceNetworkServiceAssociationsRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListServiceNetworkServiceAssociationsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListServiceNetworkServiceAssociationsResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the ListServiceNetworkServiceAssociations operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginListServiceNetworkServiceAssociations.</param>
///
/// <returns>Returns a ListServiceNetworkServiceAssociationsResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServiceNetworkServiceAssociations">REST API Reference for ListServiceNetworkServiceAssociations Operation</seealso>
public virtual ListServiceNetworkServiceAssociationsResponse EndListServiceNetworkServiceAssociations(IAsyncResult asyncResult)
{
return EndInvoke<ListServiceNetworkServiceAssociationsResponse>(asyncResult);
}
#endregion
#region ListServiceNetworkVpcAssociations
/// <summary>
/// Lists the service network and VPC associations. You can filter the list either by
/// VPC or service network. You must provide either the service network identifier or
/// the VPC identifier.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListServiceNetworkVpcAssociations service method.</param>
///
/// <returns>The response from the ListServiceNetworkVpcAssociations service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServiceNetworkVpcAssociations">REST API Reference for ListServiceNetworkVpcAssociations Operation</seealso>
public virtual ListServiceNetworkVpcAssociationsResponse ListServiceNetworkVpcAssociations(ListServiceNetworkVpcAssociationsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListServiceNetworkVpcAssociationsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListServiceNetworkVpcAssociationsResponseUnmarshaller.Instance;
return Invoke<ListServiceNetworkVpcAssociationsResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListServiceNetworkVpcAssociations operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListServiceNetworkVpcAssociations operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListServiceNetworkVpcAssociations
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServiceNetworkVpcAssociations">REST API Reference for ListServiceNetworkVpcAssociations Operation</seealso>
public virtual IAsyncResult BeginListServiceNetworkVpcAssociations(ListServiceNetworkVpcAssociationsRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListServiceNetworkVpcAssociationsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListServiceNetworkVpcAssociationsResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the ListServiceNetworkVpcAssociations operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginListServiceNetworkVpcAssociations.</param>
///
/// <returns>Returns a ListServiceNetworkVpcAssociationsResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServiceNetworkVpcAssociations">REST API Reference for ListServiceNetworkVpcAssociations Operation</seealso>
public virtual ListServiceNetworkVpcAssociationsResponse EndListServiceNetworkVpcAssociations(IAsyncResult asyncResult)
{
return EndInvoke<ListServiceNetworkVpcAssociationsResponse>(asyncResult);
}
#endregion
#region ListServices
/// <summary>
/// Lists the services owned by the caller account or shared with the caller account.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListServices service method.</param>
///
/// <returns>The response from the ListServices service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServices">REST API Reference for ListServices Operation</seealso>
public virtual ListServicesResponse ListServices(ListServicesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListServicesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListServicesResponseUnmarshaller.Instance;
return Invoke<ListServicesResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListServices operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListServices operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListServices
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServices">REST API Reference for ListServices Operation</seealso>
public virtual IAsyncResult BeginListServices(ListServicesRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListServicesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListServicesResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the ListServices operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginListServices.</param>
///
/// <returns>Returns a ListServicesResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListServices">REST API Reference for ListServices Operation</seealso>
public virtual ListServicesResponse EndListServices(IAsyncResult asyncResult)
{
return EndInvoke<ListServicesResponse>(asyncResult);
}
#endregion
#region ListTagsForResource
/// <summary>
/// Lists the tags for the specified resource.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListTagsForResource service method.</param>
///
/// <returns>The response from the ListTagsForResource service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListTagsForResource">REST API Reference for ListTagsForResource Operation</seealso>
public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance;
return Invoke<ListTagsForResourceResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListTagsForResource operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListTagsForResource operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTagsForResource
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListTagsForResource">REST API Reference for ListTagsForResource Operation</seealso>
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);
}
/// <summary>
/// Finishes the asynchronous execution of the ListTagsForResource operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginListTagsForResource.</param>
///
/// <returns>Returns a ListTagsForResourceResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListTagsForResource">REST API Reference for ListTagsForResource Operation</seealso>
public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult)
{
return EndInvoke<ListTagsForResourceResponse>(asyncResult);
}
#endregion
#region ListTargetGroups
/// <summary>
/// Lists your target groups. You can narrow your search by using the filters below in
/// your request.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListTargetGroups service method.</param>
///
/// <returns>The response from the ListTargetGroups service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListTargetGroups">REST API Reference for ListTargetGroups Operation</seealso>
public virtual ListTargetGroupsResponse ListTargetGroups(ListTargetGroupsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTargetGroupsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTargetGroupsResponseUnmarshaller.Instance;
return Invoke<ListTargetGroupsResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListTargetGroups operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListTargetGroups operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTargetGroups
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListTargetGroups">REST API Reference for ListTargetGroups Operation</seealso>
public virtual IAsyncResult BeginListTargetGroups(ListTargetGroupsRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTargetGroupsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTargetGroupsResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the ListTargetGroups operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginListTargetGroups.</param>
///
/// <returns>Returns a ListTargetGroupsResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListTargetGroups">REST API Reference for ListTargetGroups Operation</seealso>
public virtual ListTargetGroupsResponse EndListTargetGroups(IAsyncResult asyncResult)
{
return EndInvoke<ListTargetGroupsResponse>(asyncResult);
}
#endregion
#region ListTargets
/// <summary>
/// Lists the targets for the target group. By default, all targets are included. You
/// can use this API to check the health status of targets. You can also ï¬lter the results
/// by target.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListTargets service method.</param>
///
/// <returns>The response from the ListTargets service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListTargets">REST API Reference for ListTargets Operation</seealso>
public virtual ListTargetsResponse ListTargets(ListTargetsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTargetsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTargetsResponseUnmarshaller.Instance;
return Invoke<ListTargetsResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListTargets operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListTargets operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTargets
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListTargets">REST API Reference for ListTargets Operation</seealso>
public virtual IAsyncResult BeginListTargets(ListTargetsRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTargetsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTargetsResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the ListTargets operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginListTargets.</param>
///
/// <returns>Returns a ListTargetsResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/ListTargets">REST API Reference for ListTargets Operation</seealso>
public virtual ListTargetsResponse EndListTargets(IAsyncResult asyncResult)
{
return EndInvoke<ListTargetsResponse>(asyncResult);
}
#endregion
#region PutAuthPolicy
/// <summary>
/// Creates or updates the auth policy. The policy string in JSON must not contain newlines
/// or blank lines.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the PutAuthPolicy service method.</param>
///
/// <returns>The response from the PutAuthPolicy service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/PutAuthPolicy">REST API Reference for PutAuthPolicy Operation</seealso>
public virtual PutAuthPolicyResponse PutAuthPolicy(PutAuthPolicyRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = PutAuthPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutAuthPolicyResponseUnmarshaller.Instance;
return Invoke<PutAuthPolicyResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the PutAuthPolicy operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutAuthPolicy operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutAuthPolicy
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/PutAuthPolicy">REST API Reference for PutAuthPolicy Operation</seealso>
public virtual IAsyncResult BeginPutAuthPolicy(PutAuthPolicyRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = PutAuthPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutAuthPolicyResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the PutAuthPolicy operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginPutAuthPolicy.</param>
///
/// <returns>Returns a PutAuthPolicyResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/PutAuthPolicy">REST API Reference for PutAuthPolicy Operation</seealso>
public virtual PutAuthPolicyResponse EndPutAuthPolicy(IAsyncResult asyncResult)
{
return EndInvoke<PutAuthPolicyResponse>(asyncResult);
}
#endregion
#region PutResourcePolicy
/// <summary>
/// Attaches a resource-based permission policy to a service or service network. The policy
/// must contain the same actions and condition statements as the Amazon Web Services
/// Resource Access Manager permission for sharing services and service networks.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the PutResourcePolicy service method.</param>
///
/// <returns>The response from the PutResourcePolicy service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/PutResourcePolicy">REST API Reference for PutResourcePolicy Operation</seealso>
public virtual PutResourcePolicyResponse PutResourcePolicy(PutResourcePolicyRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance;
return Invoke<PutResourcePolicyResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the PutResourcePolicy operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutResourcePolicy operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutResourcePolicy
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/PutResourcePolicy">REST API Reference for PutResourcePolicy Operation</seealso>
public virtual IAsyncResult BeginPutResourcePolicy(PutResourcePolicyRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the PutResourcePolicy operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginPutResourcePolicy.</param>
///
/// <returns>Returns a PutResourcePolicyResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/PutResourcePolicy">REST API Reference for PutResourcePolicy Operation</seealso>
public virtual PutResourcePolicyResponse EndPutResourcePolicy(IAsyncResult asyncResult)
{
return EndInvoke<PutResourcePolicyResponse>(asyncResult);
}
#endregion
#region RegisterTargets
/// <summary>
/// Registers the targets with the target group. If it's a Lambda target, you can only
/// have one target in a target group.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the RegisterTargets service method.</param>
///
/// <returns>The response from the RegisterTargets service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ServiceQuotaExceededException">
/// The request would cause a service quota to be exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/RegisterTargets">REST API Reference for RegisterTargets Operation</seealso>
public virtual RegisterTargetsResponse RegisterTargets(RegisterTargetsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = RegisterTargetsRequestMarshaller.Instance;
options.ResponseUnmarshaller = RegisterTargetsResponseUnmarshaller.Instance;
return Invoke<RegisterTargetsResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the RegisterTargets operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the RegisterTargets operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterTargets
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/RegisterTargets">REST API Reference for RegisterTargets Operation</seealso>
public virtual IAsyncResult BeginRegisterTargets(RegisterTargetsRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = RegisterTargetsRequestMarshaller.Instance;
options.ResponseUnmarshaller = RegisterTargetsResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the RegisterTargets operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginRegisterTargets.</param>
///
/// <returns>Returns a RegisterTargetsResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/RegisterTargets">REST API Reference for RegisterTargets Operation</seealso>
public virtual RegisterTargetsResponse EndRegisterTargets(IAsyncResult asyncResult)
{
return EndInvoke<RegisterTargetsResponse>(asyncResult);
}
#endregion
#region TagResource
/// <summary>
/// Adds the specified tags to the specified resource.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the TagResource service method.</param>
///
/// <returns>The response from the TagResource service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/TagResource">REST API Reference for TagResource Operation</seealso>
public virtual TagResourceResponse TagResource(TagResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = TagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance;
return Invoke<TagResourceResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the TagResource operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the TagResource operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTagResource
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/TagResource">REST API Reference for TagResource Operation</seealso>
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);
}
/// <summary>
/// Finishes the asynchronous execution of the TagResource operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginTagResource.</param>
///
/// <returns>Returns a TagResourceResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/TagResource">REST API Reference for TagResource Operation</seealso>
public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult)
{
return EndInvoke<TagResourceResponse>(asyncResult);
}
#endregion
#region UntagResource
/// <summary>
/// Removes the specified tags from the specified resource.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the UntagResource service method.</param>
///
/// <returns>The response from the UntagResource service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UntagResource">REST API Reference for UntagResource Operation</seealso>
public virtual UntagResourceResponse UntagResource(UntagResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UntagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;
return Invoke<UntagResourceResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the UntagResource operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UntagResource operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUntagResource
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UntagResource">REST API Reference for UntagResource Operation</seealso>
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);
}
/// <summary>
/// Finishes the asynchronous execution of the UntagResource operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginUntagResource.</param>
///
/// <returns>Returns a UntagResourceResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UntagResource">REST API Reference for UntagResource Operation</seealso>
public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult)
{
return EndInvoke<UntagResourceResponse>(asyncResult);
}
#endregion
#region UpdateAccessLogSubscription
/// <summary>
/// Updates the specified access log subscription.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the UpdateAccessLogSubscription service method.</param>
///
/// <returns>The response from the UpdateAccessLogSubscription service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateAccessLogSubscription">REST API Reference for UpdateAccessLogSubscription Operation</seealso>
public virtual UpdateAccessLogSubscriptionResponse UpdateAccessLogSubscription(UpdateAccessLogSubscriptionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateAccessLogSubscriptionRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateAccessLogSubscriptionResponseUnmarshaller.Instance;
return Invoke<UpdateAccessLogSubscriptionResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateAccessLogSubscription operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateAccessLogSubscription operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateAccessLogSubscription
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateAccessLogSubscription">REST API Reference for UpdateAccessLogSubscription Operation</seealso>
public virtual IAsyncResult BeginUpdateAccessLogSubscription(UpdateAccessLogSubscriptionRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateAccessLogSubscriptionRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateAccessLogSubscriptionResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the UpdateAccessLogSubscription operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginUpdateAccessLogSubscription.</param>
///
/// <returns>Returns a UpdateAccessLogSubscriptionResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateAccessLogSubscription">REST API Reference for UpdateAccessLogSubscription Operation</seealso>
public virtual UpdateAccessLogSubscriptionResponse EndUpdateAccessLogSubscription(IAsyncResult asyncResult)
{
return EndInvoke<UpdateAccessLogSubscriptionResponse>(asyncResult);
}
#endregion
#region UpdateListener
/// <summary>
/// Updates the specified listener for the specified service.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the UpdateListener service method.</param>
///
/// <returns>The response from the UpdateListener service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateListener">REST API Reference for UpdateListener Operation</seealso>
public virtual UpdateListenerResponse UpdateListener(UpdateListenerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateListenerRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateListenerResponseUnmarshaller.Instance;
return Invoke<UpdateListenerResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateListener operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateListener operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateListener
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateListener">REST API Reference for UpdateListener Operation</seealso>
public virtual IAsyncResult BeginUpdateListener(UpdateListenerRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateListenerRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateListenerResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the UpdateListener operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginUpdateListener.</param>
///
/// <returns>Returns a UpdateListenerResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateListener">REST API Reference for UpdateListener Operation</seealso>
public virtual UpdateListenerResponse EndUpdateListener(IAsyncResult asyncResult)
{
return EndInvoke<UpdateListenerResponse>(asyncResult);
}
#endregion
#region UpdateRule
/// <summary>
/// Updates a rule for the listener. You can't modify a default listener rule. To modify
/// a default listener rule, use <code>UpdateListener</code>.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the UpdateRule service method.</param>
///
/// <returns>The response from the UpdateRule service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateRule">REST API Reference for UpdateRule Operation</seealso>
public virtual UpdateRuleResponse UpdateRule(UpdateRuleRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateRuleRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateRuleResponseUnmarshaller.Instance;
return Invoke<UpdateRuleResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateRule operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateRule operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateRule
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateRule">REST API Reference for UpdateRule Operation</seealso>
public virtual IAsyncResult BeginUpdateRule(UpdateRuleRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateRuleRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateRuleResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the UpdateRule operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginUpdateRule.</param>
///
/// <returns>Returns a UpdateRuleResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateRule">REST API Reference for UpdateRule Operation</seealso>
public virtual UpdateRuleResponse EndUpdateRule(IAsyncResult asyncResult)
{
return EndInvoke<UpdateRuleResponse>(asyncResult);
}
#endregion
#region UpdateService
/// <summary>
/// Updates the specified service.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the UpdateService service method.</param>
///
/// <returns>The response from the UpdateService service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateService">REST API Reference for UpdateService Operation</seealso>
public virtual UpdateServiceResponse UpdateService(UpdateServiceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateServiceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateServiceResponseUnmarshaller.Instance;
return Invoke<UpdateServiceResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateService operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateService operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateService
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateService">REST API Reference for UpdateService Operation</seealso>
public virtual IAsyncResult BeginUpdateService(UpdateServiceRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateServiceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateServiceResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the UpdateService operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginUpdateService.</param>
///
/// <returns>Returns a UpdateServiceResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateService">REST API Reference for UpdateService Operation</seealso>
public virtual UpdateServiceResponse EndUpdateService(IAsyncResult asyncResult)
{
return EndInvoke<UpdateServiceResponse>(asyncResult);
}
#endregion
#region UpdateServiceNetwork
/// <summary>
/// Updates the specified service network.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the UpdateServiceNetwork service method.</param>
///
/// <returns>The response from the UpdateServiceNetwork service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateServiceNetwork">REST API Reference for UpdateServiceNetwork Operation</seealso>
public virtual UpdateServiceNetworkResponse UpdateServiceNetwork(UpdateServiceNetworkRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateServiceNetworkRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateServiceNetworkResponseUnmarshaller.Instance;
return Invoke<UpdateServiceNetworkResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateServiceNetwork operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateServiceNetwork operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateServiceNetwork
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateServiceNetwork">REST API Reference for UpdateServiceNetwork Operation</seealso>
public virtual IAsyncResult BeginUpdateServiceNetwork(UpdateServiceNetworkRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateServiceNetworkRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateServiceNetworkResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the UpdateServiceNetwork operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginUpdateServiceNetwork.</param>
///
/// <returns>Returns a UpdateServiceNetworkResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateServiceNetwork">REST API Reference for UpdateServiceNetwork Operation</seealso>
public virtual UpdateServiceNetworkResponse EndUpdateServiceNetwork(IAsyncResult asyncResult)
{
return EndInvoke<UpdateServiceNetworkResponse>(asyncResult);
}
#endregion
#region UpdateServiceNetworkVpcAssociation
/// <summary>
/// Updates the service network and VPC association. If you add a security group to the
/// service network and VPC association, the association must continue to always have
/// at least one security group. You can add or edit security groups at any time. However,
/// to remove all security groups, you must first delete the association and recreate
/// it without security groups.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the UpdateServiceNetworkVpcAssociation service method.</param>
///
/// <returns>The response from the UpdateServiceNetworkVpcAssociation service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.AccessDeniedException">
/// The user does not have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateServiceNetworkVpcAssociation">REST API Reference for UpdateServiceNetworkVpcAssociation Operation</seealso>
public virtual UpdateServiceNetworkVpcAssociationResponse UpdateServiceNetworkVpcAssociation(UpdateServiceNetworkVpcAssociationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateServiceNetworkVpcAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateServiceNetworkVpcAssociationResponseUnmarshaller.Instance;
return Invoke<UpdateServiceNetworkVpcAssociationResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateServiceNetworkVpcAssociation operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateServiceNetworkVpcAssociation operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateServiceNetworkVpcAssociation
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateServiceNetworkVpcAssociation">REST API Reference for UpdateServiceNetworkVpcAssociation Operation</seealso>
public virtual IAsyncResult BeginUpdateServiceNetworkVpcAssociation(UpdateServiceNetworkVpcAssociationRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateServiceNetworkVpcAssociationRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateServiceNetworkVpcAssociationResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the UpdateServiceNetworkVpcAssociation operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginUpdateServiceNetworkVpcAssociation.</param>
///
/// <returns>Returns a UpdateServiceNetworkVpcAssociationResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateServiceNetworkVpcAssociation">REST API Reference for UpdateServiceNetworkVpcAssociation Operation</seealso>
public virtual UpdateServiceNetworkVpcAssociationResponse EndUpdateServiceNetworkVpcAssociation(IAsyncResult asyncResult)
{
return EndInvoke<UpdateServiceNetworkVpcAssociationResponse>(asyncResult);
}
#endregion
#region UpdateTargetGroup
/// <summary>
/// Updates the specified target group.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the UpdateTargetGroup service method.</param>
///
/// <returns>The response from the UpdateTargetGroup service method, as returned by VPCLattice.</returns>
/// <exception cref="Amazon.VPCLattice.Model.ConflictException">
/// The request conflicts with the current state of the resource. Updating or deleting
/// a resource can cause an inconsistent state.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ResourceNotFoundException">
/// The request references a resource that does not exist.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ThrottlingException">
/// The limit on the number of requests per second was exceeded.
/// </exception>
/// <exception cref="Amazon.VPCLattice.Model.ValidationException">
/// The input does not satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateTargetGroup">REST API Reference for UpdateTargetGroup Operation</seealso>
public virtual UpdateTargetGroupResponse UpdateTargetGroup(UpdateTargetGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateTargetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateTargetGroupResponseUnmarshaller.Instance;
return Invoke<UpdateTargetGroupResponse>(request, options);
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateTargetGroup operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateTargetGroup operation on AmazonVPCLatticeClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateTargetGroup
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateTargetGroup">REST API Reference for UpdateTargetGroup Operation</seealso>
public virtual IAsyncResult BeginUpdateTargetGroup(UpdateTargetGroupRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateTargetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateTargetGroupResponseUnmarshaller.Instance;
return BeginInvoke(request, options, callback, state);
}
/// <summary>
/// Finishes the asynchronous execution of the UpdateTargetGroup operation.
/// </summary>
///
/// <param name="asyncResult">The IAsyncResult returned by the call to BeginUpdateTargetGroup.</param>
///
/// <returns>Returns a UpdateTargetGroupResult from VPCLattice.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/vpc-lattice-2022-11-30/UpdateTargetGroup">REST API Reference for UpdateTargetGroup Operation</seealso>
public virtual UpdateTargetGroupResponse EndUpdateTargetGroup(IAsyncResult asyncResult)
{
return EndInvoke<UpdateTargetGroupResponse>(asyncResult);
}
#endregion
}
}