/* * 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.Runtime.ExceptionServices; using System.Threading; using System.Threading.Tasks; 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 { ///

/// 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 Amazon /// VPC Lattice User Guide ///

public partial class AmazonVPCLatticeClient : AmazonServiceClient, IAmazonVPCLattice { private static IServiceMetadata serviceMetadata = new AmazonVPCLatticeMetadata(); private IVPCLatticePaginatorFactory _paginators; ///

/// Paginators for the service ///

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

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


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

/// ///

public AmazonVPCLatticeClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonVPCLatticeConfig()) { } ///


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

/// ///

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


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

/// ///

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

/// Constructs AmazonVPCLatticeClient with AWS Credentials ///

/// AWS Credentials public AmazonVPCLatticeClient(AWSCredentials credentials) : this(credentials, new AmazonVPCLatticeConfig()) { } ///

/// Constructs AmazonVPCLatticeClient with AWS Credentials ///

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Customize the pipeline ///

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

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

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

/// Disposes the service client. ///

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

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

/// Container for the necessary parameters to execute the BatchUpdateRule service method. /// /// The response from the BatchUpdateRule service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for BatchUpdateRule Operation public virtual BatchUpdateRuleResponse BatchUpdateRule(BatchUpdateRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BatchUpdateRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchUpdateRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the BatchUpdateRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the BatchUpdateRule service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for BatchUpdateRule Operation public virtual Task BatchUpdateRuleAsync(BatchUpdateRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = BatchUpdateRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchUpdateRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateAccessLogSubscription ///

/// 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 /// Access /// logs in the Amazon VPC Lattice User Guide. ///

/// Container for the necessary parameters to execute the CreateAccessLogSubscription service method. /// /// The response from the CreateAccessLogSubscription service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateAccessLogSubscription Operation public virtual CreateAccessLogSubscriptionResponse CreateAccessLogSubscription(CreateAccessLogSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAccessLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAccessLogSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateAccessLogSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateAccessLogSubscription service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateAccessLogSubscription Operation public virtual Task CreateAccessLogSubscriptionAsync(CreateAccessLogSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAccessLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAccessLogSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateListener ///

/// 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 Listeners /// in the Amazon VPC Lattice User Guide. ///

/// Container for the necessary parameters to execute the CreateListener service method. /// /// The response from the CreateListener service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateListener Operation public virtual CreateListenerResponse CreateListener(CreateListenerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateListenerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateListener service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateListener service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateListener Operation public virtual Task CreateListenerAsync(CreateListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateListenerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateRule ///

/// 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 Listener /// rules in the Amazon VPC Lattice User Guide. ///

/// Container for the necessary parameters to execute the CreateRule service method. /// /// The response from the CreateRule service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateRule Operation public virtual CreateRuleResponse CreateRule(CreateRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateRule service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateRule Operation public virtual Task CreateRuleAsync(CreateRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateService ///

/// 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). /// /// /// /// For more information, see Services /// in the Amazon VPC Lattice User Guide. /// ///

/// Container for the necessary parameters to execute the CreateService service method. /// /// The response from the CreateService service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateService Operation public virtual CreateServiceResponse CreateService(CreateServiceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateServiceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateService service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateService service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateService Operation public virtual Task CreateServiceAsync(CreateServiceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateServiceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateServiceNetwork ///

/// 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. /// /// /// /// For more information, see Service /// networks in the Amazon VPC Lattice User Guide. /// ///

/// Container for the necessary parameters to execute the CreateServiceNetwork service method. /// /// The response from the CreateServiceNetwork service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateServiceNetwork Operation public virtual CreateServiceNetworkResponse CreateServiceNetwork(CreateServiceNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateServiceNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateServiceNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateServiceNetwork service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateServiceNetwork service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateServiceNetwork Operation public virtual Task CreateServiceNetworkAsync(CreateServiceNetworkRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateServiceNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateServiceNetworkResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateServiceNetworkServiceAssociation ///

/// Associates a service with a service network. /// /// /// /// 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. /// /// /// /// 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. /// /// /// /// As a result of this operation, the association is created in the service network account /// and the association owner account. /// ///

/// Container for the necessary parameters to execute the CreateServiceNetworkServiceAssociation service method. /// /// The response from the CreateServiceNetworkServiceAssociation service method, as returned by VPCLattice. /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateServiceNetworkServiceAssociation Operation public virtual CreateServiceNetworkServiceAssociationResponse CreateServiceNetworkServiceAssociation(CreateServiceNetworkServiceAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateServiceNetworkServiceAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateServiceNetworkServiceAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateServiceNetworkServiceAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateServiceNetworkServiceAssociation service method, as returned by VPCLattice. /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateServiceNetworkServiceAssociation Operation public virtual Task CreateServiceNetworkServiceAssociationAsync(CreateServiceNetworkServiceAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateServiceNetworkServiceAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateServiceNetworkServiceAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateServiceNetworkVpcAssociation ///

/// 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 Manage /// VPC associations in the Amazon VPC Lattice User Guide. /// /// /// /// 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. /// /// /// /// As a result of this operation, the association gets created in the service network /// account and the VPC owner account. /// /// /// /// 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. /// ///

/// Container for the necessary parameters to execute the CreateServiceNetworkVpcAssociation service method. /// /// The response from the CreateServiceNetworkVpcAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateServiceNetworkVpcAssociation Operation public virtual CreateServiceNetworkVpcAssociationResponse CreateServiceNetworkVpcAssociation(CreateServiceNetworkVpcAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateServiceNetworkVpcAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateServiceNetworkVpcAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateServiceNetworkVpcAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateServiceNetworkVpcAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateServiceNetworkVpcAssociation Operation public virtual Task CreateServiceNetworkVpcAssociationAsync(CreateServiceNetworkVpcAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateServiceNetworkVpcAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateServiceNetworkVpcAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateTargetGroup ///

/// 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. /// /// /// /// For more information, see Target /// groups in the Amazon VPC Lattice User Guide. /// ///

/// Container for the necessary parameters to execute the CreateTargetGroup service method. /// /// The response from the CreateTargetGroup service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateTargetGroup Operation public virtual CreateTargetGroupResponse CreateTargetGroup(CreateTargetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTargetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateTargetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTargetGroup service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for CreateTargetGroup Operation public virtual Task CreateTargetGroupAsync(CreateTargetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTargetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteAccessLogSubscription ///

/// Deletes the specified access log subscription. ///

/// Container for the necessary parameters to execute the DeleteAccessLogSubscription service method. /// /// The response from the DeleteAccessLogSubscription service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteAccessLogSubscription Operation public virtual DeleteAccessLogSubscriptionResponse DeleteAccessLogSubscription(DeleteAccessLogSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAccessLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAccessLogSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the specified access log subscription. ///

/// Container for the necessary parameters to execute the DeleteAccessLogSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteAccessLogSubscription service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteAccessLogSubscription Operation public virtual Task DeleteAccessLogSubscriptionAsync(DeleteAccessLogSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAccessLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAccessLogSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteAuthPolicy ///

/// Deletes the specified auth policy. If an auth is set to AWS_IAM 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 NONE. /// If auth is enabled on the resource, but no auth policy is set, all requests will be /// denied. ///

/// Container for the necessary parameters to execute the DeleteAuthPolicy service method. /// /// The response from the DeleteAuthPolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteAuthPolicy Operation public virtual DeleteAuthPolicyResponse DeleteAuthPolicy(DeleteAuthPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAuthPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAuthPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DeleteAuthPolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteAuthPolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteAuthPolicy Operation public virtual Task DeleteAuthPolicyAsync(DeleteAuthPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAuthPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAuthPolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteListener ///

/// Deletes the specified listener. ///

/// Container for the necessary parameters to execute the DeleteListener service method. /// /// The response from the DeleteListener service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteListener Operation public virtual DeleteListenerResponse DeleteListener(DeleteListenerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteListenerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the specified listener. ///

/// Container for the necessary parameters to execute the DeleteListener service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteListener service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteListener Operation public virtual Task DeleteListenerAsync(DeleteListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteListenerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteResourcePolicy ///

/// Deletes the specified resource policy. ///

/// Container for the necessary parameters to execute the DeleteResourcePolicy service method. /// /// The response from the DeleteResourcePolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteResourcePolicy Operation public virtual DeleteResourcePolicyResponse DeleteResourcePolicy(DeleteResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the specified resource policy. ///

/// Container for the necessary parameters to execute the DeleteResourcePolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteResourcePolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteResourcePolicy Operation public virtual Task DeleteResourcePolicyAsync(DeleteResourcePolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteRule ///

/// 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. /// /// /// /// For more information, see Listener /// rules in the Amazon VPC Lattice User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteRule service method. /// /// The response from the DeleteRule service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteRule Operation public virtual DeleteRuleResponse DeleteRule(DeleteRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DeleteRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteRule service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteRule Operation public virtual Task DeleteRuleAsync(DeleteRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteService ///

/// 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 Delete /// a service in the Amazon VPC Lattice User Guide. ///

/// Container for the necessary parameters to execute the DeleteService service method. /// /// The response from the DeleteService service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteService Operation public virtual DeleteServiceResponse DeleteService(DeleteServiceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteServiceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DeleteService service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteService service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteService Operation public virtual Task DeleteServiceAsync(DeleteServiceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteServiceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteServiceNetwork ///

/// 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 Delete /// a service network in the Amazon VPC Lattice User Guide. ///

/// Container for the necessary parameters to execute the DeleteServiceNetwork service method. /// /// The response from the DeleteServiceNetwork service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteServiceNetwork Operation public virtual DeleteServiceNetworkResponse DeleteServiceNetwork(DeleteServiceNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteServiceNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteServiceNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DeleteServiceNetwork service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteServiceNetwork service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteServiceNetwork Operation public virtual Task DeleteServiceNetworkAsync(DeleteServiceNetworkRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteServiceNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteServiceNetworkResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteServiceNetworkServiceAssociation ///

/// Deletes the association between a specified service and the specific service network. /// This request will fail if an association is still in progress. ///

/// Container for the necessary parameters to execute the DeleteServiceNetworkServiceAssociation service method. /// /// The response from the DeleteServiceNetworkServiceAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteServiceNetworkServiceAssociation Operation public virtual DeleteServiceNetworkServiceAssociationResponse DeleteServiceNetworkServiceAssociation(DeleteServiceNetworkServiceAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteServiceNetworkServiceAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteServiceNetworkServiceAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the association between a specified service and the specific service network. /// This request will fail if an association is still in progress. ///

/// Container for the necessary parameters to execute the DeleteServiceNetworkServiceAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteServiceNetworkServiceAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteServiceNetworkServiceAssociation Operation public virtual Task DeleteServiceNetworkServiceAssociationAsync(DeleteServiceNetworkServiceAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteServiceNetworkServiceAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteServiceNetworkServiceAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteServiceNetworkVpcAssociation ///

/// Disassociates the VPC from the service network. You can't disassociate the VPC if /// there is a create or update association in progress. ///

/// Container for the necessary parameters to execute the DeleteServiceNetworkVpcAssociation service method. /// /// The response from the DeleteServiceNetworkVpcAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteServiceNetworkVpcAssociation Operation public virtual DeleteServiceNetworkVpcAssociationResponse DeleteServiceNetworkVpcAssociation(DeleteServiceNetworkVpcAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteServiceNetworkVpcAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteServiceNetworkVpcAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Disassociates the VPC from the service network. You can't disassociate the VPC if /// there is a create or update association in progress. ///

/// Container for the necessary parameters to execute the DeleteServiceNetworkVpcAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteServiceNetworkVpcAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteServiceNetworkVpcAssociation Operation public virtual Task DeleteServiceNetworkVpcAssociationAsync(DeleteServiceNetworkVpcAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteServiceNetworkVpcAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteServiceNetworkVpcAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteTargetGroup ///

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

/// Container for the necessary parameters to execute the DeleteTargetGroup service method. /// /// The response from the DeleteTargetGroup service method, as returned by VPCLattice. /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteTargetGroup Operation public virtual DeleteTargetGroupResponse DeleteTargetGroup(DeleteTargetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTargetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DeleteTargetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTargetGroup service method, as returned by VPCLattice. /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeleteTargetGroup Operation public virtual Task DeleteTargetGroupAsync(DeleteTargetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTargetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeregisterTargets ///

/// Deregisters the specified targets from the specified target group. ///

/// Container for the necessary parameters to execute the DeregisterTargets service method. /// /// The response from the DeregisterTargets service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeregisterTargets Operation public virtual DeregisterTargetsResponse DeregisterTargets(DeregisterTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deregisters the specified targets from the specified target group. ///

/// Container for the necessary parameters to execute the DeregisterTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterTargets service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for DeregisterTargets Operation public virtual Task DeregisterTargetsAsync(DeregisterTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTargetsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetAccessLogSubscription ///

/// Retrieves information about the specified access log subscription. ///

/// Container for the necessary parameters to execute the GetAccessLogSubscription service method. /// /// The response from the GetAccessLogSubscription service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetAccessLogSubscription Operation public virtual GetAccessLogSubscriptionResponse GetAccessLogSubscription(GetAccessLogSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAccessLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAccessLogSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves information about the specified access log subscription. ///

/// Container for the necessary parameters to execute the GetAccessLogSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetAccessLogSubscription service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetAccessLogSubscription Operation public virtual Task GetAccessLogSubscriptionAsync(GetAccessLogSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetAccessLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAccessLogSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetAuthPolicy ///

/// Retrieves information about the auth policy for the specified service or service network. ///

/// Container for the necessary parameters to execute the GetAuthPolicy service method. /// /// The response from the GetAuthPolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetAuthPolicy Operation public virtual GetAuthPolicyResponse GetAuthPolicy(GetAuthPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAuthPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAuthPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves information about the auth policy for the specified service or service network. ///

/// Container for the necessary parameters to execute the GetAuthPolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetAuthPolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetAuthPolicy Operation public virtual Task GetAuthPolicyAsync(GetAuthPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetAuthPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAuthPolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetListener ///

/// Retrieves information about the specified listener for the specified service. ///

/// Container for the necessary parameters to execute the GetListener service method. /// /// The response from the GetListener service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetListener Operation public virtual GetListenerResponse GetListener(GetListenerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = GetListenerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves information about the specified listener for the specified service. ///

/// Container for the necessary parameters to execute the GetListener service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetListener service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetListener Operation public virtual Task GetListenerAsync(GetListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = GetListenerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetResourcePolicy ///

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

/// Container for the necessary parameters to execute the GetResourcePolicy service method. /// /// The response from the GetResourcePolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetResourcePolicy Operation public virtual GetResourcePolicyResponse GetResourcePolicy(GetResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the GetResourcePolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetResourcePolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetResourcePolicy Operation public virtual Task GetResourcePolicyAsync(GetResourcePolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourcePolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetRule ///

/// Retrieves information about listener rules. You can also retrieve information about /// the default listener rule. For more information, see Listener /// rules in the Amazon VPC Lattice User Guide. ///

/// Container for the necessary parameters to execute the GetRule service method. /// /// The response from the GetRule service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetRule Operation public virtual GetRuleResponse GetRule(GetRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the GetRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetRule service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetRule Operation public virtual Task GetRuleAsync(GetRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetService ///

/// Retrieves information about the specified service. ///

/// Container for the necessary parameters to execute the GetService service method. /// /// The response from the GetService service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetService Operation public virtual GetServiceResponse GetService(GetServiceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves information about the specified service. ///

/// Container for the necessary parameters to execute the GetService service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetService service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetService Operation public virtual Task GetServiceAsync(GetServiceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetServiceNetwork ///

/// Retrieves information about the specified service network. ///

/// Container for the necessary parameters to execute the GetServiceNetwork service method. /// /// The response from the GetServiceNetwork service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetServiceNetwork Operation public virtual GetServiceNetworkResponse GetServiceNetwork(GetServiceNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves information about the specified service network. ///

/// Container for the necessary parameters to execute the GetServiceNetwork service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetServiceNetwork service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetServiceNetwork Operation public virtual Task GetServiceNetworkAsync(GetServiceNetworkRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceNetworkResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetServiceNetworkServiceAssociation ///

/// Retrieves information about the specified association between a service network and /// a service. ///

/// Container for the necessary parameters to execute the GetServiceNetworkServiceAssociation service method. /// /// The response from the GetServiceNetworkServiceAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetServiceNetworkServiceAssociation Operation public virtual GetServiceNetworkServiceAssociationResponse GetServiceNetworkServiceAssociation(GetServiceNetworkServiceAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceNetworkServiceAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceNetworkServiceAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves information about the specified association between a service network and /// a service. ///

/// Container for the necessary parameters to execute the GetServiceNetworkServiceAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetServiceNetworkServiceAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetServiceNetworkServiceAssociation Operation public virtual Task GetServiceNetworkServiceAssociationAsync(GetServiceNetworkServiceAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceNetworkServiceAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceNetworkServiceAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetServiceNetworkVpcAssociation ///

/// Retrieves information about the association between a service network and a VPC. ///

/// Container for the necessary parameters to execute the GetServiceNetworkVpcAssociation service method. /// /// The response from the GetServiceNetworkVpcAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetServiceNetworkVpcAssociation Operation public virtual GetServiceNetworkVpcAssociationResponse GetServiceNetworkVpcAssociation(GetServiceNetworkVpcAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceNetworkVpcAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceNetworkVpcAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves information about the association between a service network and a VPC. ///

/// Container for the necessary parameters to execute the GetServiceNetworkVpcAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetServiceNetworkVpcAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetServiceNetworkVpcAssociation Operation public virtual Task GetServiceNetworkVpcAssociationAsync(GetServiceNetworkVpcAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceNetworkVpcAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceNetworkVpcAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetTargetGroup ///

/// Retrieves information about the specified target group. ///

/// Container for the necessary parameters to execute the GetTargetGroup service method. /// /// The response from the GetTargetGroup service method, as returned by VPCLattice. /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetTargetGroup Operation public virtual GetTargetGroupResponse GetTargetGroup(GetTargetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTargetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves information about the specified target group. ///

/// Container for the necessary parameters to execute the GetTargetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetTargetGroup service method, as returned by VPCLattice. /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for GetTargetGroup Operation public virtual Task GetTargetGroupAsync(GetTargetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTargetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListAccessLogSubscriptions ///

/// Lists all access log subscriptions for the specified service network or service. ///

/// Container for the necessary parameters to execute the ListAccessLogSubscriptions service method. /// /// The response from the ListAccessLogSubscriptions service method, as returned by VPCLattice. /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListAccessLogSubscriptions Operation public virtual ListAccessLogSubscriptionsResponse ListAccessLogSubscriptions(ListAccessLogSubscriptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAccessLogSubscriptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAccessLogSubscriptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists all access log subscriptions for the specified service network or service. ///

/// Container for the necessary parameters to execute the ListAccessLogSubscriptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListAccessLogSubscriptions service method, as returned by VPCLattice. /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListAccessLogSubscriptions Operation public virtual Task ListAccessLogSubscriptionsAsync(ListAccessLogSubscriptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListAccessLogSubscriptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAccessLogSubscriptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListListeners ///

/// Lists the listeners for the specified service. ///

/// Container for the necessary parameters to execute the ListListeners service method. /// /// The response from the ListListeners service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListListeners Operation public virtual ListListenersResponse ListListeners(ListListenersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListListenersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListListenersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists the listeners for the specified service. ///

/// Container for the necessary parameters to execute the ListListeners service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListListeners service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListListeners Operation public virtual Task ListListenersAsync(ListListenersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListListenersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListListenersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListRules ///

/// Lists the rules for the listener. ///

/// Container for the necessary parameters to execute the ListRules service method. /// /// The response from the ListRules service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListRules Operation public virtual ListRulesResponse ListRules(ListRulesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListRulesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRulesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists the rules for the listener. ///

/// Container for the necessary parameters to execute the ListRules service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListRules service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListRules Operation public virtual Task ListRulesAsync(ListRulesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListRulesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRulesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListServiceNetworks ///

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

/// Container for the necessary parameters to execute the ListServiceNetworks service method. /// /// The response from the ListServiceNetworks service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListServiceNetworks Operation public virtual ListServiceNetworksResponse ListServiceNetworks(ListServiceNetworksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListServiceNetworksRequestMarshaller.Instance; options.ResponseUnmarshaller = ListServiceNetworksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListServiceNetworks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListServiceNetworks service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListServiceNetworks Operation public virtual Task ListServiceNetworksAsync(ListServiceNetworksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListServiceNetworksRequestMarshaller.Instance; options.ResponseUnmarshaller = ListServiceNetworksResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListServiceNetworkServiceAssociations ///

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

/// Container for the necessary parameters to execute the ListServiceNetworkServiceAssociations service method. /// /// The response from the ListServiceNetworkServiceAssociations service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListServiceNetworkServiceAssociations Operation public virtual ListServiceNetworkServiceAssociationsResponse ListServiceNetworkServiceAssociations(ListServiceNetworkServiceAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListServiceNetworkServiceAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListServiceNetworkServiceAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the ListServiceNetworkServiceAssociations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListServiceNetworkServiceAssociations service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListServiceNetworkServiceAssociations Operation public virtual Task ListServiceNetworkServiceAssociationsAsync(ListServiceNetworkServiceAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListServiceNetworkServiceAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListServiceNetworkServiceAssociationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListServiceNetworkVpcAssociations ///

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

/// Container for the necessary parameters to execute the ListServiceNetworkVpcAssociations service method. /// /// The response from the ListServiceNetworkVpcAssociations service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListServiceNetworkVpcAssociations Operation public virtual ListServiceNetworkVpcAssociationsResponse ListServiceNetworkVpcAssociations(ListServiceNetworkVpcAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListServiceNetworkVpcAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListServiceNetworkVpcAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListServiceNetworkVpcAssociations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListServiceNetworkVpcAssociations service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListServiceNetworkVpcAssociations Operation public virtual Task ListServiceNetworkVpcAssociationsAsync(ListServiceNetworkVpcAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListServiceNetworkVpcAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListServiceNetworkVpcAssociationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListServices ///

/// Lists the services owned by the caller account or shared with the caller account. ///

/// Container for the necessary parameters to execute the ListServices service method. /// /// The response from the ListServices service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListServices Operation public virtual ListServicesResponse ListServices(ListServicesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListServicesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListServicesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists the services owned by the caller account or shared with the caller account. ///

/// Container for the necessary parameters to execute the ListServices service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListServices service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListServices Operation public virtual Task ListServicesAsync(ListServicesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListServicesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListServicesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListTagsForResource ///

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

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by VPCLattice. /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListTagsForResource service method, as returned by VPCLattice. /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListTagsForResource Operation public virtual Task ListTagsForResourceAsync(ListTagsForResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListTargetGroups ///

/// Lists your target groups. You can narrow your search by using the filters below in /// your request. ///

/// Container for the necessary parameters to execute the ListTargetGroups service method. /// /// The response from the ListTargetGroups service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListTargetGroups Operation public virtual ListTargetGroupsResponse ListTargetGroups(ListTargetGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTargetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTargetGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists your target groups. You can narrow your search by using the filters below in /// your request. ///

/// Container for the necessary parameters to execute the ListTargetGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListTargetGroups service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListTargetGroups Operation public virtual Task ListTargetGroupsAsync(ListTargetGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListTargetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTargetGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListTargets ///

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

/// Container for the necessary parameters to execute the ListTargets service method. /// /// The response from the ListTargets service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListTargets Operation public virtual ListTargetsResponse ListTargets(ListTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListTargets service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for ListTargets Operation public virtual Task ListTargetsAsync(ListTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTargetsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PutAuthPolicy ///

/// Creates or updates the auth policy. The policy string in JSON must not contain newlines /// or blank lines. ///

/// Container for the necessary parameters to execute the PutAuthPolicy service method. /// /// The response from the PutAuthPolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for PutAuthPolicy Operation public virtual PutAuthPolicyResponse PutAuthPolicy(PutAuthPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutAuthPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutAuthPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates or updates the auth policy. The policy string in JSON must not contain newlines /// or blank lines. ///

/// Container for the necessary parameters to execute the PutAuthPolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the PutAuthPolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for PutAuthPolicy Operation public virtual Task PutAuthPolicyAsync(PutAuthPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PutAuthPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutAuthPolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PutResourcePolicy ///

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

/// Container for the necessary parameters to execute the PutResourcePolicy service method. /// /// The response from the PutResourcePolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for PutResourcePolicy Operation public virtual PutResourcePolicyResponse PutResourcePolicy(PutResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the PutResourcePolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the PutResourcePolicy service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for PutResourcePolicy Operation public virtual Task PutResourcePolicyAsync(PutResourcePolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RegisterTargets ///

/// Registers the targets with the target group. If it's a Lambda target, you can only /// have one target in a target group. ///

/// Container for the necessary parameters to execute the RegisterTargets service method. /// /// The response from the RegisterTargets service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for RegisterTargets Operation public virtual RegisterTargetsResponse RegisterTargets(RegisterTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Registers the targets with the target group. If it's a Lambda target, you can only /// have one target in a target group. ///

/// Container for the necessary parameters to execute the RegisterTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RegisterTargets service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The request would cause a service quota to be exceeded. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for RegisterTargets Operation public virtual Task RegisterTargetsAsync(RegisterTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTargetsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region TagResource ///

/// Adds the specified tags to the specified resource. ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for TagResource Operation public virtual TagResourceResponse TagResource(TagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Adds the specified tags to the specified resource. ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the TagResource service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for TagResource Operation public virtual Task TagResourceAsync(TagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UntagResource ///

/// Removes the specified tags from the specified resource. ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by VPCLattice. /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse UntagResource(UntagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Removes the specified tags from the specified resource. ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UntagResource service method, as returned by VPCLattice. /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UntagResource Operation public virtual Task UntagResourceAsync(UntagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateAccessLogSubscription ///

/// Updates the specified access log subscription. ///

/// Container for the necessary parameters to execute the UpdateAccessLogSubscription service method. /// /// The response from the UpdateAccessLogSubscription service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateAccessLogSubscription Operation public virtual UpdateAccessLogSubscriptionResponse UpdateAccessLogSubscription(UpdateAccessLogSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAccessLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAccessLogSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Updates the specified access log subscription. ///

/// Container for the necessary parameters to execute the UpdateAccessLogSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UpdateAccessLogSubscription service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateAccessLogSubscription Operation public virtual Task UpdateAccessLogSubscriptionAsync(UpdateAccessLogSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAccessLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAccessLogSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateListener ///

/// Updates the specified listener for the specified service. ///

/// Container for the necessary parameters to execute the UpdateListener service method. /// /// The response from the UpdateListener service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateListener Operation public virtual UpdateListenerResponse UpdateListener(UpdateListenerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateListenerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Updates the specified listener for the specified service. ///

/// Container for the necessary parameters to execute the UpdateListener service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UpdateListener service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateListener Operation public virtual Task UpdateListenerAsync(UpdateListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateListenerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateRule ///

/// Updates a rule for the listener. You can't modify a default listener rule. To modify /// a default listener rule, use UpdateListener. ///

/// Container for the necessary parameters to execute the UpdateRule service method. /// /// The response from the UpdateRule service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateRule Operation public virtual UpdateRuleResponse UpdateRule(UpdateRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Updates a rule for the listener. You can't modify a default listener rule. To modify /// a default listener rule, use UpdateListener. ///

/// Container for the necessary parameters to execute the UpdateRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UpdateRule service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateRule Operation public virtual Task UpdateRuleAsync(UpdateRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateService ///

/// Updates the specified service. ///

/// Container for the necessary parameters to execute the UpdateService service method. /// /// The response from the UpdateService service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateService Operation public virtual UpdateServiceResponse UpdateService(UpdateServiceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateServiceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Updates the specified service. ///

/// Container for the necessary parameters to execute the UpdateService service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UpdateService service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateService Operation public virtual Task UpdateServiceAsync(UpdateServiceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateServiceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateServiceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateServiceNetwork ///

/// Updates the specified service network. ///

/// Container for the necessary parameters to execute the UpdateServiceNetwork service method. /// /// The response from the UpdateServiceNetwork service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateServiceNetwork Operation public virtual UpdateServiceNetworkResponse UpdateServiceNetwork(UpdateServiceNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateServiceNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateServiceNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Updates the specified service network. ///

/// Container for the necessary parameters to execute the UpdateServiceNetwork service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UpdateServiceNetwork service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateServiceNetwork Operation public virtual Task UpdateServiceNetworkAsync(UpdateServiceNetworkRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateServiceNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateServiceNetworkResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateServiceNetworkVpcAssociation ///

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

/// Container for the necessary parameters to execute the UpdateServiceNetworkVpcAssociation service method. /// /// The response from the UpdateServiceNetworkVpcAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateServiceNetworkVpcAssociation Operation public virtual UpdateServiceNetworkVpcAssociationResponse UpdateServiceNetworkVpcAssociation(UpdateServiceNetworkVpcAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateServiceNetworkVpcAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateServiceNetworkVpcAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the UpdateServiceNetworkVpcAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UpdateServiceNetworkVpcAssociation service method, as returned by VPCLattice. /// /// The user does not have sufficient access to perform this action. /// /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateServiceNetworkVpcAssociation Operation public virtual Task UpdateServiceNetworkVpcAssociationAsync(UpdateServiceNetworkVpcAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateServiceNetworkVpcAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateServiceNetworkVpcAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateTargetGroup ///

/// Updates the specified target group. ///

/// Container for the necessary parameters to execute the UpdateTargetGroup service method. /// /// The response from the UpdateTargetGroup service method, as returned by VPCLattice. /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateTargetGroup Operation public virtual UpdateTargetGroupResponse UpdateTargetGroup(UpdateTargetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateTargetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Updates the specified target group. ///

/// Container for the necessary parameters to execute the UpdateTargetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UpdateTargetGroup service method, as returned by VPCLattice. /// /// The request conflicts with the current state of the resource. Updating or deleting /// a resource can cause an inconsistent state. /// /// /// An unexpected error occurred while processing the request. /// /// /// The request references a resource that does not exist. /// /// /// The limit on the number of requests per second was exceeded. /// /// /// The input does not satisfy the constraints specified by an Amazon Web Services service. /// /// REST API Reference for UpdateTargetGroup Operation public virtual Task UpdateTargetGroupAsync(UpdateTargetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateTargetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion } }