/* * 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 networkmanager-2019-07-05.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.NetworkManager.Model; using Amazon.NetworkManager.Model.Internal.MarshallTransformations; using Amazon.NetworkManager.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.NetworkManager { ///

/// Implementation for accessing NetworkManager /// /// Amazon Web Services enables you to centrally manage your Amazon Web Services Cloud /// WAN core network and your Transit Gateway network across Amazon Web Services accounts, /// Regions, and on-premises locations. ///

public partial class AmazonNetworkManagerClient : AmazonServiceClient, IAmazonNetworkManager { private static IServiceMetadata serviceMetadata = new AmazonNetworkManagerMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private INetworkManagerPaginatorFactory _paginators; ///

/// Paginators for the service ///

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

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


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

/// ///

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


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

/// ///

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

/// Constructs AmazonNetworkManagerClient with AWS Credentials ///

/// AWS Credentials public AmazonNetworkManagerClient(AWSCredentials credentials) : this(credentials, new AmazonNetworkManagerConfig()) { } ///

/// Constructs AmazonNetworkManagerClient with AWS Credentials ///

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Accepts a core network attachment request. /// /// /// /// Once the attachment request is accepted by a core network owner, the attachment is /// created and connected to a core network. /// ///

/// Container for the necessary parameters to execute the AcceptAttachment service method. /// /// The response from the AcceptAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for AcceptAttachment Operation public virtual AcceptAttachmentResponse AcceptAttachment(AcceptAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginAcceptAttachment. /// /// Returns a AcceptAttachmentResult from NetworkManager. /// REST API Reference for AcceptAttachment Operation public virtual AcceptAttachmentResponse EndAcceptAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AssociateConnectPeer ///

/// Associates a core network Connect peer with a device and optionally, with a link. /// /// /// /// /// If you specify a link, it must be associated with the specified device. You can only /// associate core network Connect peers that have been created on a core network Connect /// attachment on a core network. /// ///

/// Container for the necessary parameters to execute the AssociateConnectPeer service method. /// /// The response from the AssociateConnectPeer service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for AssociateConnectPeer Operation public virtual AssociateConnectPeerResponse AssociateConnectPeer(AssociateConnectPeerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateConnectPeerRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateConnectPeerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginAssociateConnectPeer. /// /// Returns a AssociateConnectPeerResult from NetworkManager. /// REST API Reference for AssociateConnectPeer Operation public virtual AssociateConnectPeerResponse EndAssociateConnectPeer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AssociateCustomerGateway ///

/// Associates a customer gateway with a device and optionally, with a link. If you specify /// a link, it must be associated with the specified device. /// /// /// /// You can only associate customer gateways that are connected to a VPN attachment on /// a transit gateway or core network registered in your global network. When you register /// a transit gateway or core network, customer gateways that are connected to the transit /// gateway are automatically included in the global network. To list customer gateways /// that are connected to a transit gateway, use the DescribeVpnConnections /// EC2 API and filter by transit-gateway-id. /// /// /// /// You cannot associate a customer gateway with more than one device and link. /// ///

/// Container for the necessary parameters to execute the AssociateCustomerGateway service method. /// /// The response from the AssociateCustomerGateway service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for AssociateCustomerGateway Operation public virtual AssociateCustomerGatewayResponse AssociateCustomerGateway(AssociateCustomerGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateCustomerGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateCustomerGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginAssociateCustomerGateway. /// /// Returns a AssociateCustomerGatewayResult from NetworkManager. /// REST API Reference for AssociateCustomerGateway Operation public virtual AssociateCustomerGatewayResponse EndAssociateCustomerGateway(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AssociateLink ///

/// Associates a link to a device. A device can be associated to multiple links and a /// link can be associated to multiple devices. The device and link must be in the same /// global network and the same site. ///

/// Container for the necessary parameters to execute the AssociateLink service method. /// /// The response from the AssociateLink service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for AssociateLink Operation public virtual AssociateLinkResponse AssociateLink(AssociateLinkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateLinkRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateLinkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginAssociateLink. /// /// Returns a AssociateLinkResult from NetworkManager. /// REST API Reference for AssociateLink Operation public virtual AssociateLinkResponse EndAssociateLink(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AssociateTransitGatewayConnectPeer ///

/// Associates a transit gateway Connect peer with a device, and optionally, with a link. /// If you specify a link, it must be associated with the specified device. /// /// /// /// You can only associate transit gateway Connect peers that have been created on a transit /// gateway that's registered in your global network. /// /// /// /// You cannot associate a transit gateway Connect peer with more than one device and /// link. /// ///

/// Container for the necessary parameters to execute the AssociateTransitGatewayConnectPeer service method. /// /// The response from the AssociateTransitGatewayConnectPeer service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for AssociateTransitGatewayConnectPeer Operation public virtual AssociateTransitGatewayConnectPeerResponse AssociateTransitGatewayConnectPeer(AssociateTransitGatewayConnectPeerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateTransitGatewayConnectPeerRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateTransitGatewayConnectPeerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginAssociateTransitGatewayConnectPeer. /// /// Returns a AssociateTransitGatewayConnectPeerResult from NetworkManager. /// REST API Reference for AssociateTransitGatewayConnectPeer Operation public virtual AssociateTransitGatewayConnectPeerResponse EndAssociateTransitGatewayConnectPeer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateConnectAttachment ///

/// Creates a core network Connect attachment from a specified core network attachment. /// /// /// /// /// A core network Connect attachment is a GRE-based tunnel attachment that you can use /// to establish a connection between a core network and an appliance. A core network /// Connect attachment uses an existing VPC attachment as the underlying transport mechanism. /// ///

/// Container for the necessary parameters to execute the CreateConnectAttachment service method. /// /// The response from the CreateConnectAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateConnectAttachment Operation public virtual CreateConnectAttachmentResponse CreateConnectAttachment(CreateConnectAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConnectAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConnectAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateConnectAttachment. /// /// Returns a CreateConnectAttachmentResult from NetworkManager. /// REST API Reference for CreateConnectAttachment Operation public virtual CreateConnectAttachmentResponse EndCreateConnectAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateConnection ///

/// Creates a connection between two devices. The devices can be a physical or virtual /// appliance that connects to a third-party appliance in a VPC, or a physical appliance /// that connects to another physical appliance in an on-premises network. ///

/// Container for the necessary parameters to execute the CreateConnection service method. /// /// The response from the CreateConnection service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateConnection Operation public virtual CreateConnectionResponse CreateConnection(CreateConnectionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConnectionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateConnection. /// /// Returns a CreateConnectionResult from NetworkManager. /// REST API Reference for CreateConnection Operation public virtual CreateConnectionResponse EndCreateConnection(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateConnectPeer ///

/// Creates a core network Connect peer for a specified core network connect attachment /// between a core network and an appliance. The peer address and transit gateway address /// must be the same IP address family (IPv4 or IPv6). ///

/// Container for the necessary parameters to execute the CreateConnectPeer service method. /// /// The response from the CreateConnectPeer service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateConnectPeer Operation public virtual CreateConnectPeerResponse CreateConnectPeer(CreateConnectPeerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConnectPeerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConnectPeerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateConnectPeer. /// /// Returns a CreateConnectPeerResult from NetworkManager. /// REST API Reference for CreateConnectPeer Operation public virtual CreateConnectPeerResponse EndCreateConnectPeer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateCoreNetwork ///

/// Creates a core network as part of your global network, and optionally, with a core /// network policy. ///

/// Container for the necessary parameters to execute the CreateCoreNetwork service method. /// /// The response from the CreateCoreNetwork service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// Describes a core network policy exception. /// /// /// The request has failed due to an internal error. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateCoreNetwork Operation public virtual CreateCoreNetworkResponse CreateCoreNetwork(CreateCoreNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCoreNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCoreNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateCoreNetwork. /// /// Returns a CreateCoreNetworkResult from NetworkManager. /// REST API Reference for CreateCoreNetwork Operation public virtual CreateCoreNetworkResponse EndCreateCoreNetwork(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDevice ///

/// Creates a new device in a global network. If you specify both a site ID and a location, /// the location of the site is used for visualization in the Network Manager console. ///

/// Container for the necessary parameters to execute the CreateDevice service method. /// /// The response from the CreateDevice service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateDevice Operation public virtual CreateDeviceResponse CreateDevice(CreateDeviceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDeviceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDeviceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateDevice. /// /// Returns a CreateDeviceResult from NetworkManager. /// REST API Reference for CreateDevice Operation public virtual CreateDeviceResponse EndCreateDevice(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateGlobalNetwork ///

/// Creates a new, empty global network. ///

/// Container for the necessary parameters to execute the CreateGlobalNetwork service method. /// /// The response from the CreateGlobalNetwork service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateGlobalNetwork Operation public virtual CreateGlobalNetworkResponse CreateGlobalNetwork(CreateGlobalNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateGlobalNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateGlobalNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateGlobalNetwork. /// /// Returns a CreateGlobalNetworkResult from NetworkManager. /// REST API Reference for CreateGlobalNetwork Operation public virtual CreateGlobalNetworkResponse EndCreateGlobalNetwork(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLink ///

/// Creates a new link for a specified site. ///

/// Container for the necessary parameters to execute the CreateLink service method. /// /// The response from the CreateLink service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateLink Operation public virtual CreateLinkResponse CreateLink(CreateLinkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLinkRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLinkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateLink. /// /// Returns a CreateLinkResult from NetworkManager. /// REST API Reference for CreateLink Operation public virtual CreateLinkResponse EndCreateLink(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateSite ///

/// Creates a new site in a global network. ///

/// Container for the necessary parameters to execute the CreateSite service method. /// /// The response from the CreateSite service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateSite Operation public virtual CreateSiteResponse CreateSite(CreateSiteRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSiteRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSiteResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateSite. /// /// Returns a CreateSiteResult from NetworkManager. /// REST API Reference for CreateSite Operation public virtual CreateSiteResponse EndCreateSite(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateSiteToSiteVpnAttachment ///

/// Creates an Amazon Web Services site-to-site VPN attachment on an edge location of /// a core network. ///

/// Container for the necessary parameters to execute the CreateSiteToSiteVpnAttachment service method. /// /// The response from the CreateSiteToSiteVpnAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateSiteToSiteVpnAttachment Operation public virtual CreateSiteToSiteVpnAttachmentResponse CreateSiteToSiteVpnAttachment(CreateSiteToSiteVpnAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSiteToSiteVpnAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSiteToSiteVpnAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateSiteToSiteVpnAttachment. /// /// Returns a CreateSiteToSiteVpnAttachmentResult from NetworkManager. /// REST API Reference for CreateSiteToSiteVpnAttachment Operation public virtual CreateSiteToSiteVpnAttachmentResponse EndCreateSiteToSiteVpnAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateTransitGatewayPeering ///

/// Creates a transit gateway peering connection. ///

/// Container for the necessary parameters to execute the CreateTransitGatewayPeering service method. /// /// The response from the CreateTransitGatewayPeering service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateTransitGatewayPeering Operation public virtual CreateTransitGatewayPeeringResponse CreateTransitGatewayPeering(CreateTransitGatewayPeeringRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayPeeringRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayPeeringResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateTransitGatewayPeering. /// /// Returns a CreateTransitGatewayPeeringResult from NetworkManager. /// REST API Reference for CreateTransitGatewayPeering Operation public virtual CreateTransitGatewayPeeringResponse EndCreateTransitGatewayPeering(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateTransitGatewayRouteTableAttachment ///

/// Creates a transit gateway route table attachment. ///

/// Container for the necessary parameters to execute the CreateTransitGatewayRouteTableAttachment service method. /// /// The response from the CreateTransitGatewayRouteTableAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateTransitGatewayRouteTableAttachment Operation public virtual CreateTransitGatewayRouteTableAttachmentResponse CreateTransitGatewayRouteTableAttachment(CreateTransitGatewayRouteTableAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayRouteTableAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayRouteTableAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateTransitGatewayRouteTableAttachment. /// /// Returns a CreateTransitGatewayRouteTableAttachmentResult from NetworkManager. /// REST API Reference for CreateTransitGatewayRouteTableAttachment Operation public virtual CreateTransitGatewayRouteTableAttachmentResponse EndCreateTransitGatewayRouteTableAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateVpcAttachment ///

/// Creates a VPC attachment on an edge location of a core network. ///

/// Container for the necessary parameters to execute the CreateVpcAttachment service method. /// /// The response from the CreateVpcAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for CreateVpcAttachment Operation public virtual CreateVpcAttachmentResponse CreateVpcAttachment(CreateVpcAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVpcAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVpcAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateVpcAttachment. /// /// Returns a CreateVpcAttachmentResult from NetworkManager. /// REST API Reference for CreateVpcAttachment Operation public virtual CreateVpcAttachmentResponse EndCreateVpcAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteAttachment ///

/// Deletes an attachment. Supports all attachment types. ///

/// Container for the necessary parameters to execute the DeleteAttachment service method. /// /// The response from the DeleteAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DeleteAttachment Operation public virtual DeleteAttachmentResponse DeleteAttachment(DeleteAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteAttachment. /// /// Returns a DeleteAttachmentResult from NetworkManager. /// REST API Reference for DeleteAttachment Operation public virtual DeleteAttachmentResponse EndDeleteAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteConnection ///

/// Deletes the specified connection in your global network. ///

/// Container for the necessary parameters to execute the DeleteConnection service method. /// /// The response from the DeleteConnection service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DeleteConnection Operation public virtual DeleteConnectionResponse DeleteConnection(DeleteConnectionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConnectionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteConnection. /// /// Returns a DeleteConnectionResult from NetworkManager. /// REST API Reference for DeleteConnection Operation public virtual DeleteConnectionResponse EndDeleteConnection(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteConnectPeer ///

/// Deletes a Connect peer. ///

/// Container for the necessary parameters to execute the DeleteConnectPeer service method. /// /// The response from the DeleteConnectPeer service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DeleteConnectPeer Operation public virtual DeleteConnectPeerResponse DeleteConnectPeer(DeleteConnectPeerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConnectPeerRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConnectPeerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteConnectPeer. /// /// Returns a DeleteConnectPeerResult from NetworkManager. /// REST API Reference for DeleteConnectPeer Operation public virtual DeleteConnectPeerResponse EndDeleteConnectPeer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteCoreNetwork ///

/// Deletes a core network along with all core network policies. This can only be done /// if there are no attachments on a core network. ///

/// Container for the necessary parameters to execute the DeleteCoreNetwork service method. /// /// The response from the DeleteCoreNetwork service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DeleteCoreNetwork Operation public virtual DeleteCoreNetworkResponse DeleteCoreNetwork(DeleteCoreNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCoreNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCoreNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteCoreNetwork. /// /// Returns a DeleteCoreNetworkResult from NetworkManager. /// REST API Reference for DeleteCoreNetwork Operation public virtual DeleteCoreNetworkResponse EndDeleteCoreNetwork(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteCoreNetworkPolicyVersion ///

/// Deletes a policy version from a core network. You can't delete the current LIVE policy. ///

/// Container for the necessary parameters to execute the DeleteCoreNetworkPolicyVersion service method. /// /// The response from the DeleteCoreNetworkPolicyVersion service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DeleteCoreNetworkPolicyVersion Operation public virtual DeleteCoreNetworkPolicyVersionResponse DeleteCoreNetworkPolicyVersion(DeleteCoreNetworkPolicyVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCoreNetworkPolicyVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCoreNetworkPolicyVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteCoreNetworkPolicyVersion. /// /// Returns a DeleteCoreNetworkPolicyVersionResult from NetworkManager. /// REST API Reference for DeleteCoreNetworkPolicyVersion Operation public virtual DeleteCoreNetworkPolicyVersionResponse EndDeleteCoreNetworkPolicyVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteDevice ///

/// Deletes an existing device. You must first disassociate the device from any links /// and customer gateways. ///

/// Container for the necessary parameters to execute the DeleteDevice service method. /// /// The response from the DeleteDevice service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DeleteDevice Operation public virtual DeleteDeviceResponse DeleteDevice(DeleteDeviceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDeviceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDeviceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteDevice. /// /// Returns a DeleteDeviceResult from NetworkManager. /// REST API Reference for DeleteDevice Operation public virtual DeleteDeviceResponse EndDeleteDevice(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteGlobalNetwork ///

/// Deletes an existing global network. You must first delete all global network objects /// (devices, links, and sites), deregister all transit gateways, and delete any core /// networks. ///

/// Container for the necessary parameters to execute the DeleteGlobalNetwork service method. /// /// The response from the DeleteGlobalNetwork service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DeleteGlobalNetwork Operation public virtual DeleteGlobalNetworkResponse DeleteGlobalNetwork(DeleteGlobalNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteGlobalNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteGlobalNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteGlobalNetwork. /// /// Returns a DeleteGlobalNetworkResult from NetworkManager. /// REST API Reference for DeleteGlobalNetwork Operation public virtual DeleteGlobalNetworkResponse EndDeleteGlobalNetwork(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteLink ///

/// Deletes an existing link. You must first disassociate the link from any devices and /// customer gateways. ///

/// Container for the necessary parameters to execute the DeleteLink service method. /// /// The response from the DeleteLink service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DeleteLink Operation public virtual DeleteLinkResponse DeleteLink(DeleteLinkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLinkRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLinkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteLink. /// /// Returns a DeleteLinkResult from NetworkManager. /// REST API Reference for DeleteLink Operation public virtual DeleteLinkResponse EndDeleteLink(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeletePeering ///

/// Deletes an existing peering connection. ///

/// Container for the necessary parameters to execute the DeletePeering service method. /// /// The response from the DeletePeering service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DeletePeering Operation public virtual DeletePeeringResponse DeletePeering(DeletePeeringRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePeeringRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePeeringResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeletePeering. /// /// Returns a DeletePeeringResult from NetworkManager. /// REST API Reference for DeletePeering Operation public virtual DeletePeeringResponse EndDeletePeering(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteResourcePolicy ///

/// Deletes a resource policy for the specified resource. This revokes the access of the /// principals specified in the resource policy. ///

/// Container for the necessary parameters to execute the DeleteResourcePolicy service method. /// /// The response from the DeleteResourcePolicy service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// 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); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteResourcePolicy. /// /// Returns a DeleteResourcePolicyResult from NetworkManager. /// REST API Reference for DeleteResourcePolicy Operation public virtual DeleteResourcePolicyResponse EndDeleteResourcePolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteSite ///

/// Deletes an existing site. The site cannot be associated with any device or link. ///

/// Container for the necessary parameters to execute the DeleteSite service method. /// /// The response from the DeleteSite service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DeleteSite Operation public virtual DeleteSiteResponse DeleteSite(DeleteSiteRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSiteRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSiteResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteSite. /// /// Returns a DeleteSiteResult from NetworkManager. /// REST API Reference for DeleteSite Operation public virtual DeleteSiteResponse EndDeleteSite(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeregisterTransitGateway ///

/// Deregisters a transit gateway from your global network. This action does not delete /// your transit gateway, or modify any of its attachments. This action removes any customer /// gateway associations. ///

/// Container for the necessary parameters to execute the DeregisterTransitGateway service method. /// /// The response from the DeregisterTransitGateway service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DeregisterTransitGateway Operation public virtual DeregisterTransitGatewayResponse DeregisterTransitGateway(DeregisterTransitGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTransitGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTransitGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeregisterTransitGateway. /// /// Returns a DeregisterTransitGatewayResult from NetworkManager. /// REST API Reference for DeregisterTransitGateway Operation public virtual DeregisterTransitGatewayResponse EndDeregisterTransitGateway(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeGlobalNetworks ///

/// Describes one or more global networks. By default, all global networks are described. /// To describe the objects in your global network, you must use the appropriate Get* /// action. For example, to list the transit gateways in your global network, use GetTransitGatewayRegistrations. ///

/// Container for the necessary parameters to execute the DescribeGlobalNetworks service method. /// /// The response from the DescribeGlobalNetworks service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DescribeGlobalNetworks Operation public virtual DescribeGlobalNetworksResponse DescribeGlobalNetworks(DescribeGlobalNetworksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeGlobalNetworksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeGlobalNetworksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDescribeGlobalNetworks. /// /// Returns a DescribeGlobalNetworksResult from NetworkManager. /// REST API Reference for DescribeGlobalNetworks Operation public virtual DescribeGlobalNetworksResponse EndDescribeGlobalNetworks(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisassociateConnectPeer ///

/// Disassociates a core network Connect peer from a device and a link. ///

/// Container for the necessary parameters to execute the DisassociateConnectPeer service method. /// /// The response from the DisassociateConnectPeer service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DisassociateConnectPeer Operation public virtual DisassociateConnectPeerResponse DisassociateConnectPeer(DisassociateConnectPeerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateConnectPeerRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateConnectPeerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDisassociateConnectPeer. /// /// Returns a DisassociateConnectPeerResult from NetworkManager. /// REST API Reference for DisassociateConnectPeer Operation public virtual DisassociateConnectPeerResponse EndDisassociateConnectPeer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisassociateCustomerGateway ///

/// Disassociates a customer gateway from a device and a link. ///

/// Container for the necessary parameters to execute the DisassociateCustomerGateway service method. /// /// The response from the DisassociateCustomerGateway service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DisassociateCustomerGateway Operation public virtual DisassociateCustomerGatewayResponse DisassociateCustomerGateway(DisassociateCustomerGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateCustomerGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateCustomerGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDisassociateCustomerGateway. /// /// Returns a DisassociateCustomerGatewayResult from NetworkManager. /// REST API Reference for DisassociateCustomerGateway Operation public virtual DisassociateCustomerGatewayResponse EndDisassociateCustomerGateway(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisassociateLink ///

/// Disassociates an existing device from a link. You must first disassociate any customer /// gateways that are associated with the link. ///

/// Container for the necessary parameters to execute the DisassociateLink service method. /// /// The response from the DisassociateLink service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DisassociateLink Operation public virtual DisassociateLinkResponse DisassociateLink(DisassociateLinkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateLinkRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateLinkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDisassociateLink. /// /// Returns a DisassociateLinkResult from NetworkManager. /// REST API Reference for DisassociateLink Operation public virtual DisassociateLinkResponse EndDisassociateLink(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisassociateTransitGatewayConnectPeer ///

/// Disassociates a transit gateway Connect peer from a device and link. ///

/// Container for the necessary parameters to execute the DisassociateTransitGatewayConnectPeer service method. /// /// The response from the DisassociateTransitGatewayConnectPeer service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for DisassociateTransitGatewayConnectPeer Operation public virtual DisassociateTransitGatewayConnectPeerResponse DisassociateTransitGatewayConnectPeer(DisassociateTransitGatewayConnectPeerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateTransitGatewayConnectPeerRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateTransitGatewayConnectPeerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDisassociateTransitGatewayConnectPeer. /// /// Returns a DisassociateTransitGatewayConnectPeerResult from NetworkManager. /// REST API Reference for DisassociateTransitGatewayConnectPeer Operation public virtual DisassociateTransitGatewayConnectPeerResponse EndDisassociateTransitGatewayConnectPeer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ExecuteCoreNetworkChangeSet ///

/// Executes a change set on your core network. Deploys changes globally based on the /// policy submitted.. ///

/// Container for the necessary parameters to execute the ExecuteCoreNetworkChangeSet service method. /// /// The response from the ExecuteCoreNetworkChangeSet service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for ExecuteCoreNetworkChangeSet Operation public virtual ExecuteCoreNetworkChangeSetResponse ExecuteCoreNetworkChangeSet(ExecuteCoreNetworkChangeSetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ExecuteCoreNetworkChangeSetRequestMarshaller.Instance; options.ResponseUnmarshaller = ExecuteCoreNetworkChangeSetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginExecuteCoreNetworkChangeSet. /// /// Returns a ExecuteCoreNetworkChangeSetResult from NetworkManager. /// REST API Reference for ExecuteCoreNetworkChangeSet Operation public virtual ExecuteCoreNetworkChangeSetResponse EndExecuteCoreNetworkChangeSet(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetConnectAttachment ///

/// Returns information about a core network Connect attachment. ///

/// Container for the necessary parameters to execute the GetConnectAttachment service method. /// /// The response from the GetConnectAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetConnectAttachment Operation public virtual GetConnectAttachmentResponse GetConnectAttachment(GetConnectAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetConnectAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConnectAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetConnectAttachment. /// /// Returns a GetConnectAttachmentResult from NetworkManager. /// REST API Reference for GetConnectAttachment Operation public virtual GetConnectAttachmentResponse EndGetConnectAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetConnections ///

/// Gets information about one or more of your connections in a global network. ///

/// Container for the necessary parameters to execute the GetConnections service method. /// /// The response from the GetConnections service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetConnections Operation public virtual GetConnectionsResponse GetConnections(GetConnectionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetConnectionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConnectionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetConnections. /// /// Returns a GetConnectionsResult from NetworkManager. /// REST API Reference for GetConnections Operation public virtual GetConnectionsResponse EndGetConnections(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetConnectPeer ///

/// Returns information about a core network Connect peer. ///

/// Container for the necessary parameters to execute the GetConnectPeer service method. /// /// The response from the GetConnectPeer service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetConnectPeer Operation public virtual GetConnectPeerResponse GetConnectPeer(GetConnectPeerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetConnectPeerRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConnectPeerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetConnectPeer. /// /// Returns a GetConnectPeerResult from NetworkManager. /// REST API Reference for GetConnectPeer Operation public virtual GetConnectPeerResponse EndGetConnectPeer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetConnectPeerAssociations ///

/// Returns information about a core network Connect peer associations. ///

/// Container for the necessary parameters to execute the GetConnectPeerAssociations service method. /// /// The response from the GetConnectPeerAssociations service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetConnectPeerAssociations Operation public virtual GetConnectPeerAssociationsResponse GetConnectPeerAssociations(GetConnectPeerAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetConnectPeerAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConnectPeerAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetConnectPeerAssociations. /// /// Returns a GetConnectPeerAssociationsResult from NetworkManager. /// REST API Reference for GetConnectPeerAssociations Operation public virtual GetConnectPeerAssociationsResponse EndGetConnectPeerAssociations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCoreNetwork ///

/// Returns information about the LIVE policy for a core network. ///

/// Container for the necessary parameters to execute the GetCoreNetwork service method. /// /// The response from the GetCoreNetwork service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetCoreNetwork Operation public virtual GetCoreNetworkResponse GetCoreNetwork(GetCoreNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCoreNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCoreNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetCoreNetwork. /// /// Returns a GetCoreNetworkResult from NetworkManager. /// REST API Reference for GetCoreNetwork Operation public virtual GetCoreNetworkResponse EndGetCoreNetwork(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCoreNetworkChangeEvents ///

/// Returns information about a core network change event. ///

/// Container for the necessary parameters to execute the GetCoreNetworkChangeEvents service method. /// /// The response from the GetCoreNetworkChangeEvents service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetCoreNetworkChangeEvents Operation public virtual GetCoreNetworkChangeEventsResponse GetCoreNetworkChangeEvents(GetCoreNetworkChangeEventsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCoreNetworkChangeEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCoreNetworkChangeEventsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetCoreNetworkChangeEvents. /// /// Returns a GetCoreNetworkChangeEventsResult from NetworkManager. /// REST API Reference for GetCoreNetworkChangeEvents Operation public virtual GetCoreNetworkChangeEventsResponse EndGetCoreNetworkChangeEvents(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCoreNetworkChangeSet ///

/// Returns a change set between the LIVE core network policy and a submitted policy. ///

/// Container for the necessary parameters to execute the GetCoreNetworkChangeSet service method. /// /// The response from the GetCoreNetworkChangeSet service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetCoreNetworkChangeSet Operation public virtual GetCoreNetworkChangeSetResponse GetCoreNetworkChangeSet(GetCoreNetworkChangeSetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCoreNetworkChangeSetRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCoreNetworkChangeSetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetCoreNetworkChangeSet. /// /// Returns a GetCoreNetworkChangeSetResult from NetworkManager. /// REST API Reference for GetCoreNetworkChangeSet Operation public virtual GetCoreNetworkChangeSetResponse EndGetCoreNetworkChangeSet(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCoreNetworkPolicy ///

/// Returns details about a core network policy. You can get details about your current /// live policy or any previous policy version. ///

/// Container for the necessary parameters to execute the GetCoreNetworkPolicy service method. /// /// The response from the GetCoreNetworkPolicy service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetCoreNetworkPolicy Operation public virtual GetCoreNetworkPolicyResponse GetCoreNetworkPolicy(GetCoreNetworkPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCoreNetworkPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCoreNetworkPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetCoreNetworkPolicy. /// /// Returns a GetCoreNetworkPolicyResult from NetworkManager. /// REST API Reference for GetCoreNetworkPolicy Operation public virtual GetCoreNetworkPolicyResponse EndGetCoreNetworkPolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCustomerGatewayAssociations ///

/// Gets the association information for customer gateways that are associated with devices /// and links in your global network. ///

/// Container for the necessary parameters to execute the GetCustomerGatewayAssociations service method. /// /// The response from the GetCustomerGatewayAssociations service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetCustomerGatewayAssociations Operation public virtual GetCustomerGatewayAssociationsResponse GetCustomerGatewayAssociations(GetCustomerGatewayAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCustomerGatewayAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCustomerGatewayAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetCustomerGatewayAssociations. /// /// Returns a GetCustomerGatewayAssociationsResult from NetworkManager. /// REST API Reference for GetCustomerGatewayAssociations Operation public virtual GetCustomerGatewayAssociationsResponse EndGetCustomerGatewayAssociations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDevices ///

/// Gets information about one or more of your devices in a global network. ///

/// Container for the necessary parameters to execute the GetDevices service method. /// /// The response from the GetDevices service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetDevices Operation public virtual GetDevicesResponse GetDevices(GetDevicesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDevicesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDevicesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetDevices. /// /// Returns a GetDevicesResult from NetworkManager. /// REST API Reference for GetDevices Operation public virtual GetDevicesResponse EndGetDevices(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLinkAssociations ///

/// Gets the link associations for a device or a link. Either the device ID or the link /// ID must be specified. ///

/// Container for the necessary parameters to execute the GetLinkAssociations service method. /// /// The response from the GetLinkAssociations service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetLinkAssociations Operation public virtual GetLinkAssociationsResponse GetLinkAssociations(GetLinkAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLinkAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLinkAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetLinkAssociations. /// /// Returns a GetLinkAssociationsResult from NetworkManager. /// REST API Reference for GetLinkAssociations Operation public virtual GetLinkAssociationsResponse EndGetLinkAssociations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLinks ///

/// Gets information about one or more links in a specified global network. /// /// /// /// If you specify the site ID, you cannot specify the type or provider in the same request. /// You can specify the type and provider in the same request. /// ///

/// Container for the necessary parameters to execute the GetLinks service method. /// /// The response from the GetLinks service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetLinks Operation public virtual GetLinksResponse GetLinks(GetLinksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLinksRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLinksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetLinks. /// /// Returns a GetLinksResult from NetworkManager. /// REST API Reference for GetLinks Operation public virtual GetLinksResponse EndGetLinks(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetNetworkResourceCounts ///

/// Gets the count of network resources, by resource type, for the specified global network. ///

/// Container for the necessary parameters to execute the GetNetworkResourceCounts service method. /// /// The response from the GetNetworkResourceCounts service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetNetworkResourceCounts Operation public virtual GetNetworkResourceCountsResponse GetNetworkResourceCounts(GetNetworkResourceCountsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetNetworkResourceCountsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetNetworkResourceCountsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetNetworkResourceCounts. /// /// Returns a GetNetworkResourceCountsResult from NetworkManager. /// REST API Reference for GetNetworkResourceCounts Operation public virtual GetNetworkResourceCountsResponse EndGetNetworkResourceCounts(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetNetworkResourceRelationships ///

/// Gets the network resource relationships for the specified global network. ///

/// Container for the necessary parameters to execute the GetNetworkResourceRelationships service method. /// /// The response from the GetNetworkResourceRelationships service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetNetworkResourceRelationships Operation public virtual GetNetworkResourceRelationshipsResponse GetNetworkResourceRelationships(GetNetworkResourceRelationshipsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetNetworkResourceRelationshipsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetNetworkResourceRelationshipsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetNetworkResourceRelationships. /// /// Returns a GetNetworkResourceRelationshipsResult from NetworkManager. /// REST API Reference for GetNetworkResourceRelationships Operation public virtual GetNetworkResourceRelationshipsResponse EndGetNetworkResourceRelationships(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetNetworkResources ///

/// Describes the network resources for the specified global network. /// /// /// /// The results include information from the corresponding Describe call for the resource, /// minus any sensitive information such as pre-shared keys. /// ///

/// Container for the necessary parameters to execute the GetNetworkResources service method. /// /// The response from the GetNetworkResources service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetNetworkResources Operation public virtual GetNetworkResourcesResponse GetNetworkResources(GetNetworkResourcesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetNetworkResourcesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetNetworkResourcesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetNetworkResources. /// /// Returns a GetNetworkResourcesResult from NetworkManager. /// REST API Reference for GetNetworkResources Operation public virtual GetNetworkResourcesResponse EndGetNetworkResources(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetNetworkRoutes ///

/// Gets the network routes of the specified global network. ///

/// Container for the necessary parameters to execute the GetNetworkRoutes service method. /// /// The response from the GetNetworkRoutes service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetNetworkRoutes Operation public virtual GetNetworkRoutesResponse GetNetworkRoutes(GetNetworkRoutesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetNetworkRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetNetworkRoutesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetNetworkRoutes. /// /// Returns a GetNetworkRoutesResult from NetworkManager. /// REST API Reference for GetNetworkRoutes Operation public virtual GetNetworkRoutesResponse EndGetNetworkRoutes(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetNetworkTelemetry ///

/// Gets the network telemetry of the specified global network. ///

/// Container for the necessary parameters to execute the GetNetworkTelemetry service method. /// /// The response from the GetNetworkTelemetry service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetNetworkTelemetry Operation public virtual GetNetworkTelemetryResponse GetNetworkTelemetry(GetNetworkTelemetryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetNetworkTelemetryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetNetworkTelemetryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetNetworkTelemetry. /// /// Returns a GetNetworkTelemetryResult from NetworkManager. /// REST API Reference for GetNetworkTelemetry Operation public virtual GetNetworkTelemetryResponse EndGetNetworkTelemetry(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetResourcePolicy ///

/// Returns information about a resource policy. ///

/// Container for the necessary parameters to execute the GetResourcePolicy service method. /// /// The response from the GetResourcePolicy service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// 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); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetResourcePolicy. /// /// Returns a GetResourcePolicyResult from NetworkManager. /// REST API Reference for GetResourcePolicy Operation public virtual GetResourcePolicyResponse EndGetResourcePolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRouteAnalysis ///

/// Gets information about the specified route analysis. ///

/// Container for the necessary parameters to execute the GetRouteAnalysis service method. /// /// The response from the GetRouteAnalysis service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetRouteAnalysis Operation public virtual GetRouteAnalysisResponse GetRouteAnalysis(GetRouteAnalysisRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRouteAnalysisRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRouteAnalysisResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetRouteAnalysis. /// /// Returns a GetRouteAnalysisResult from NetworkManager. /// REST API Reference for GetRouteAnalysis Operation public virtual GetRouteAnalysisResponse EndGetRouteAnalysis(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetSites ///

/// Gets information about one or more of your sites in a global network. ///

/// Container for the necessary parameters to execute the GetSites service method. /// /// The response from the GetSites service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetSites Operation public virtual GetSitesResponse GetSites(GetSitesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSitesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSitesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetSites. /// /// Returns a GetSitesResult from NetworkManager. /// REST API Reference for GetSites Operation public virtual GetSitesResponse EndGetSites(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetSiteToSiteVpnAttachment ///

/// Returns information about a site-to-site VPN attachment. ///

/// Container for the necessary parameters to execute the GetSiteToSiteVpnAttachment service method. /// /// The response from the GetSiteToSiteVpnAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetSiteToSiteVpnAttachment Operation public virtual GetSiteToSiteVpnAttachmentResponse GetSiteToSiteVpnAttachment(GetSiteToSiteVpnAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSiteToSiteVpnAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSiteToSiteVpnAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetSiteToSiteVpnAttachment. /// /// Returns a GetSiteToSiteVpnAttachmentResult from NetworkManager. /// REST API Reference for GetSiteToSiteVpnAttachment Operation public virtual GetSiteToSiteVpnAttachmentResponse EndGetSiteToSiteVpnAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetTransitGatewayConnectPeerAssociations ///

/// Gets information about one or more of your transit gateway Connect peer associations /// in a global network. ///

/// Container for the necessary parameters to execute the GetTransitGatewayConnectPeerAssociations service method. /// /// The response from the GetTransitGatewayConnectPeerAssociations service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetTransitGatewayConnectPeerAssociations Operation public virtual GetTransitGatewayConnectPeerAssociationsResponse GetTransitGatewayConnectPeerAssociations(GetTransitGatewayConnectPeerAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetTransitGatewayConnectPeerAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTransitGatewayConnectPeerAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetTransitGatewayConnectPeerAssociations. /// /// Returns a GetTransitGatewayConnectPeerAssociationsResult from NetworkManager. /// REST API Reference for GetTransitGatewayConnectPeerAssociations Operation public virtual GetTransitGatewayConnectPeerAssociationsResponse EndGetTransitGatewayConnectPeerAssociations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetTransitGatewayPeering ///

/// Returns information about a transit gateway peer. ///

/// Container for the necessary parameters to execute the GetTransitGatewayPeering service method. /// /// The response from the GetTransitGatewayPeering service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetTransitGatewayPeering Operation public virtual GetTransitGatewayPeeringResponse GetTransitGatewayPeering(GetTransitGatewayPeeringRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetTransitGatewayPeeringRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTransitGatewayPeeringResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetTransitGatewayPeering. /// /// Returns a GetTransitGatewayPeeringResult from NetworkManager. /// REST API Reference for GetTransitGatewayPeering Operation public virtual GetTransitGatewayPeeringResponse EndGetTransitGatewayPeering(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetTransitGatewayRegistrations ///

/// Gets information about the transit gateway registrations in a specified global network. ///

/// Container for the necessary parameters to execute the GetTransitGatewayRegistrations service method. /// /// The response from the GetTransitGatewayRegistrations service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetTransitGatewayRegistrations Operation public virtual GetTransitGatewayRegistrationsResponse GetTransitGatewayRegistrations(GetTransitGatewayRegistrationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetTransitGatewayRegistrationsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTransitGatewayRegistrationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetTransitGatewayRegistrations. /// /// Returns a GetTransitGatewayRegistrationsResult from NetworkManager. /// REST API Reference for GetTransitGatewayRegistrations Operation public virtual GetTransitGatewayRegistrationsResponse EndGetTransitGatewayRegistrations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetTransitGatewayRouteTableAttachment ///

/// Returns information about a transit gateway route table attachment. ///

/// Container for the necessary parameters to execute the GetTransitGatewayRouteTableAttachment service method. /// /// The response from the GetTransitGatewayRouteTableAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetTransitGatewayRouteTableAttachment Operation public virtual GetTransitGatewayRouteTableAttachmentResponse GetTransitGatewayRouteTableAttachment(GetTransitGatewayRouteTableAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetTransitGatewayRouteTableAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTransitGatewayRouteTableAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetTransitGatewayRouteTableAttachment. /// /// Returns a GetTransitGatewayRouteTableAttachmentResult from NetworkManager. /// REST API Reference for GetTransitGatewayRouteTableAttachment Operation public virtual GetTransitGatewayRouteTableAttachmentResponse EndGetTransitGatewayRouteTableAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetVpcAttachment ///

/// Returns information about a VPC attachment. ///

/// Container for the necessary parameters to execute the GetVpcAttachment service method. /// /// The response from the GetVpcAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for GetVpcAttachment Operation public virtual GetVpcAttachmentResponse GetVpcAttachment(GetVpcAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetVpcAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetVpcAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetVpcAttachment. /// /// Returns a GetVpcAttachmentResult from NetworkManager. /// REST API Reference for GetVpcAttachment Operation public virtual GetVpcAttachmentResponse EndGetVpcAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListAttachments ///

/// Returns a list of core network attachments. ///

/// Container for the necessary parameters to execute the ListAttachments service method. /// /// The response from the ListAttachments service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for ListAttachments Operation public virtual ListAttachmentsResponse ListAttachments(ListAttachmentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAttachmentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAttachmentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListAttachments. /// /// Returns a ListAttachmentsResult from NetworkManager. /// REST API Reference for ListAttachments Operation public virtual ListAttachmentsResponse EndListAttachments(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListConnectPeers ///

/// Returns a list of core network Connect peers. ///

/// Container for the necessary parameters to execute the ListConnectPeers service method. /// /// The response from the ListConnectPeers service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for ListConnectPeers Operation public virtual ListConnectPeersResponse ListConnectPeers(ListConnectPeersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListConnectPeersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListConnectPeersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListConnectPeers. /// /// Returns a ListConnectPeersResult from NetworkManager. /// REST API Reference for ListConnectPeers Operation public virtual ListConnectPeersResponse EndListConnectPeers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListCoreNetworkPolicyVersions ///

/// Returns a list of core network policy versions. ///

/// Container for the necessary parameters to execute the ListCoreNetworkPolicyVersions service method. /// /// The response from the ListCoreNetworkPolicyVersions service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for ListCoreNetworkPolicyVersions Operation public virtual ListCoreNetworkPolicyVersionsResponse ListCoreNetworkPolicyVersions(ListCoreNetworkPolicyVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListCoreNetworkPolicyVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCoreNetworkPolicyVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListCoreNetworkPolicyVersions. /// /// Returns a ListCoreNetworkPolicyVersionsResult from NetworkManager. /// REST API Reference for ListCoreNetworkPolicyVersions Operation public virtual ListCoreNetworkPolicyVersionsResponse EndListCoreNetworkPolicyVersions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListCoreNetworks ///

/// Returns a list of owned and shared core networks. ///

/// Container for the necessary parameters to execute the ListCoreNetworks service method. /// /// The response from the ListCoreNetworks service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for ListCoreNetworks Operation public virtual ListCoreNetworksResponse ListCoreNetworks(ListCoreNetworksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListCoreNetworksRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCoreNetworksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListCoreNetworks. /// /// Returns a ListCoreNetworksResult from NetworkManager. /// REST API Reference for ListCoreNetworks Operation public virtual ListCoreNetworksResponse EndListCoreNetworks(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListOrganizationServiceAccessStatus ///

/// Gets the status of the Service Linked Role (SLR) deployment for the accounts in a /// given Amazon Web Services Organization. ///

/// Container for the necessary parameters to execute the ListOrganizationServiceAccessStatus service method. /// /// The response from the ListOrganizationServiceAccessStatus service method, as returned by NetworkManager. /// REST API Reference for ListOrganizationServiceAccessStatus Operation public virtual ListOrganizationServiceAccessStatusResponse ListOrganizationServiceAccessStatus(ListOrganizationServiceAccessStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListOrganizationServiceAccessStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOrganizationServiceAccessStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListOrganizationServiceAccessStatus. /// /// Returns a ListOrganizationServiceAccessStatusResult from NetworkManager. /// REST API Reference for ListOrganizationServiceAccessStatus Operation public virtual ListOrganizationServiceAccessStatusResponse EndListOrganizationServiceAccessStatus(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListPeerings ///

/// Lists the peerings for a core network. ///

/// Container for the necessary parameters to execute the ListPeerings service method. /// /// The response from the ListPeerings service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for ListPeerings Operation public virtual ListPeeringsResponse ListPeerings(ListPeeringsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListPeeringsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListPeeringsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListPeerings. /// /// Returns a ListPeeringsResult from NetworkManager. /// REST API Reference for ListPeerings Operation public virtual ListPeeringsResponse EndListPeerings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

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

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

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

/// Creates a new, immutable version of a core network policy. A subsequent change set /// is created showing the differences between the LIVE policy and the submitted policy. ///

/// Container for the necessary parameters to execute the PutCoreNetworkPolicy service method. /// /// The response from the PutCoreNetworkPolicy service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// Describes a core network policy exception. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for PutCoreNetworkPolicy Operation public virtual PutCoreNetworkPolicyResponse PutCoreNetworkPolicy(PutCoreNetworkPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutCoreNetworkPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutCoreNetworkPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginPutCoreNetworkPolicy. /// /// Returns a PutCoreNetworkPolicyResult from NetworkManager. /// REST API Reference for PutCoreNetworkPolicy Operation public virtual PutCoreNetworkPolicyResponse EndPutCoreNetworkPolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PutResourcePolicy ///

/// Creates or updates a resource policy. ///

/// Container for the necessary parameters to execute the PutResourcePolicy service method. /// /// The response from the PutResourcePolicy service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// 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); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginPutResourcePolicy. /// /// Returns a PutResourcePolicyResult from NetworkManager. /// REST API Reference for PutResourcePolicy Operation public virtual PutResourcePolicyResponse EndPutResourcePolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RegisterTransitGateway ///

/// Registers a transit gateway in your global network. Not all Regions support transit /// gateways for global networks. For a list of the supported Regions, see Region /// Availability in the Amazon Web Services Transit Gateways for Global Networks /// User Guide. The transit gateway can be in any of the supported Amazon Web Services /// Regions, but it must be owned by the same Amazon Web Services account that owns the /// global network. You cannot register a transit gateway in more than one global network. ///

/// Container for the necessary parameters to execute the RegisterTransitGateway service method. /// /// The response from the RegisterTransitGateway service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for RegisterTransitGateway Operation public virtual RegisterTransitGatewayResponse RegisterTransitGateway(RegisterTransitGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTransitGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTransitGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginRegisterTransitGateway. /// /// Returns a RegisterTransitGatewayResult from NetworkManager. /// REST API Reference for RegisterTransitGateway Operation public virtual RegisterTransitGatewayResponse EndRegisterTransitGateway(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RejectAttachment ///

/// Rejects a core network attachment request. ///

/// Container for the necessary parameters to execute the RejectAttachment service method. /// /// The response from the RejectAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for RejectAttachment Operation public virtual RejectAttachmentResponse RejectAttachment(RejectAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RejectAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginRejectAttachment. /// /// Returns a RejectAttachmentResult from NetworkManager. /// REST API Reference for RejectAttachment Operation public virtual RejectAttachmentResponse EndRejectAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RestoreCoreNetworkPolicyVersion ///

/// Restores a previous policy version as a new, immutable version of a core network policy. /// A subsequent change set is created showing the differences between the LIVE policy /// and restored policy. ///

/// Container for the necessary parameters to execute the RestoreCoreNetworkPolicyVersion service method. /// /// The response from the RestoreCoreNetworkPolicyVersion service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for RestoreCoreNetworkPolicyVersion Operation public virtual RestoreCoreNetworkPolicyVersionResponse RestoreCoreNetworkPolicyVersion(RestoreCoreNetworkPolicyVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreCoreNetworkPolicyVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreCoreNetworkPolicyVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginRestoreCoreNetworkPolicyVersion. /// /// Returns a RestoreCoreNetworkPolicyVersionResult from NetworkManager. /// REST API Reference for RestoreCoreNetworkPolicyVersion Operation public virtual RestoreCoreNetworkPolicyVersionResponse EndRestoreCoreNetworkPolicyVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartOrganizationServiceAccessUpdate ///

/// Enables the Network Manager service for an Amazon Web Services Organization. This /// can only be called by a management account within the organization. ///

/// Container for the necessary parameters to execute the StartOrganizationServiceAccessUpdate service method. /// /// The response from the StartOrganizationServiceAccessUpdate service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for StartOrganizationServiceAccessUpdate Operation public virtual StartOrganizationServiceAccessUpdateResponse StartOrganizationServiceAccessUpdate(StartOrganizationServiceAccessUpdateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartOrganizationServiceAccessUpdateRequestMarshaller.Instance; options.ResponseUnmarshaller = StartOrganizationServiceAccessUpdateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginStartOrganizationServiceAccessUpdate. /// /// Returns a StartOrganizationServiceAccessUpdateResult from NetworkManager. /// REST API Reference for StartOrganizationServiceAccessUpdate Operation public virtual StartOrganizationServiceAccessUpdateResponse EndStartOrganizationServiceAccessUpdate(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartRouteAnalysis ///

/// Starts analyzing the routing path between the specified source and destination. For /// more information, see Route /// Analyzer. ///

/// Container for the necessary parameters to execute the StartRouteAnalysis service method. /// /// The response from the StartRouteAnalysis service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for StartRouteAnalysis Operation public virtual StartRouteAnalysisResponse StartRouteAnalysis(StartRouteAnalysisRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartRouteAnalysisRequestMarshaller.Instance; options.ResponseUnmarshaller = StartRouteAnalysisResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginStartRouteAnalysis. /// /// Returns a StartRouteAnalysisResult from NetworkManager. /// REST API Reference for StartRouteAnalysis Operation public virtual StartRouteAnalysisResponse EndStartRouteAnalysis(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource ///

/// Tags a specified resource. ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for TagResource Operation public virtual TagResourceResponse TagResource(TagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

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

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

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse UntagResource(UntagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

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

/// Updates the information for an existing connection. To remove information for any /// of the parameters, specify an empty string. ///

/// Container for the necessary parameters to execute the UpdateConnection service method. /// /// The response from the UpdateConnection service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for UpdateConnection Operation public virtual UpdateConnectionResponse UpdateConnection(UpdateConnectionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConnectionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateConnection. /// /// Returns a UpdateConnectionResult from NetworkManager. /// REST API Reference for UpdateConnection Operation public virtual UpdateConnectionResponse EndUpdateConnection(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateCoreNetwork ///

/// Updates the description of a core network. ///

/// Container for the necessary parameters to execute the UpdateCoreNetwork service method. /// /// The response from the UpdateCoreNetwork service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for UpdateCoreNetwork Operation public virtual UpdateCoreNetworkResponse UpdateCoreNetwork(UpdateCoreNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateCoreNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateCoreNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateCoreNetwork. /// /// Returns a UpdateCoreNetworkResult from NetworkManager. /// REST API Reference for UpdateCoreNetwork Operation public virtual UpdateCoreNetworkResponse EndUpdateCoreNetwork(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateDevice ///

/// Updates the details for an existing device. To remove information for any of the parameters, /// specify an empty string. ///

/// Container for the necessary parameters to execute the UpdateDevice service method. /// /// The response from the UpdateDevice service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for UpdateDevice Operation public virtual UpdateDeviceResponse UpdateDevice(UpdateDeviceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDeviceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDeviceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateDevice. /// /// Returns a UpdateDeviceResult from NetworkManager. /// REST API Reference for UpdateDevice Operation public virtual UpdateDeviceResponse EndUpdateDevice(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateGlobalNetwork ///

/// Updates an existing global network. To remove information for any of the parameters, /// specify an empty string. ///

/// Container for the necessary parameters to execute the UpdateGlobalNetwork service method. /// /// The response from the UpdateGlobalNetwork service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for UpdateGlobalNetwork Operation public virtual UpdateGlobalNetworkResponse UpdateGlobalNetwork(UpdateGlobalNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateGlobalNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateGlobalNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateGlobalNetwork. /// /// Returns a UpdateGlobalNetworkResult from NetworkManager. /// REST API Reference for UpdateGlobalNetwork Operation public virtual UpdateGlobalNetworkResponse EndUpdateGlobalNetwork(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateLink ///

/// Updates the details for an existing link. To remove information for any of the parameters, /// specify an empty string. ///

/// Container for the necessary parameters to execute the UpdateLink service method. /// /// The response from the UpdateLink service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// A service limit was exceeded. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for UpdateLink Operation public virtual UpdateLinkResponse UpdateLink(UpdateLinkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLinkRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLinkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateLink. /// /// Returns a UpdateLinkResult from NetworkManager. /// REST API Reference for UpdateLink Operation public virtual UpdateLinkResponse EndUpdateLink(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateNetworkResourceMetadata ///

/// Updates the resource metadata for the specified global network. ///

/// Container for the necessary parameters to execute the UpdateNetworkResourceMetadata service method. /// /// The response from the UpdateNetworkResourceMetadata service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for UpdateNetworkResourceMetadata Operation public virtual UpdateNetworkResourceMetadataResponse UpdateNetworkResourceMetadata(UpdateNetworkResourceMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateNetworkResourceMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateNetworkResourceMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateNetworkResourceMetadata. /// /// Returns a UpdateNetworkResourceMetadataResult from NetworkManager. /// REST API Reference for UpdateNetworkResourceMetadata Operation public virtual UpdateNetworkResourceMetadataResponse EndUpdateNetworkResourceMetadata(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateSite ///

/// Updates the information for an existing site. To remove information for any of the /// parameters, specify an empty string. ///

/// Container for the necessary parameters to execute the UpdateSite service method. /// /// The response from the UpdateSite service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for UpdateSite Operation public virtual UpdateSiteResponse UpdateSite(UpdateSiteRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSiteRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSiteResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateSite. /// /// Returns a UpdateSiteResult from NetworkManager. /// REST API Reference for UpdateSite Operation public virtual UpdateSiteResponse EndUpdateSite(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateVpcAttachment ///

/// Updates a VPC attachment. ///

/// Container for the necessary parameters to execute the UpdateVpcAttachment service method. /// /// The response from the UpdateVpcAttachment service method, as returned by NetworkManager. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict processing the request. Updating or deleting the resource can /// cause an inconsistent state. /// /// /// The request has failed due to an internal error. /// /// /// The specified resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints. /// /// REST API Reference for UpdateVpcAttachment Operation public virtual UpdateVpcAttachmentResponse UpdateVpcAttachment(UpdateVpcAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateVpcAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateVpcAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateVpcAttachment. /// /// Returns a UpdateVpcAttachmentResult from NetworkManager. /// REST API Reference for UpdateVpcAttachment Operation public virtual UpdateVpcAttachmentResponse EndUpdateVpcAttachment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }