Documentation

Overview

    Package networkmanager provides the API client, operations, and parameter types for AWS Network Manager.

    Transit Gateway Network Manager (Network Manager) enables you to create a global network, in which you can monitor your AWS and on-premises networks that are built around transit gateways. The Network Manager APIs are supported in the US West (Oregon) Region only. You must specify the us-west-2 Region in all requests made to Network Manager.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2019-07-05"
    View Source
    const ServiceID = "NetworkManager"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type AssociateCustomerGatewayInput

          type AssociateCustomerGatewayInput struct {
          
          	// The Amazon Resource Name (ARN) of the customer gateway. For more information,
          	// see Resources Defined by Amazon EC2
          	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonec2.html#amazonec2-resources-for-iam-policies).
          	//
          	// This member is required.
          	CustomerGatewayArn *string
          
          	// The ID of the device.
          	//
          	// This member is required.
          	DeviceId *string
          
          	// The ID of the global network.
          	//
          	// This member is required.
          	GlobalNetworkId *string
          
          	// The ID of the link.
          	LinkId *string
          }

          type AssociateCustomerGatewayOutput

          type AssociateCustomerGatewayOutput struct {
          
          	// The customer gateway association.
          	CustomerGatewayAssociation *types.CustomerGatewayAssociation
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type AssociateLinkInput

          type AssociateLinkInput struct {
          
          	// The ID of the device.
          	//
          	// This member is required.
          	DeviceId *string
          
          	// The ID of the global network.
          	//
          	// This member is required.
          	GlobalNetworkId *string
          
          	// The ID of the link.
          	//
          	// This member is required.
          	LinkId *string
          }

          type AssociateLinkOutput

          type AssociateLinkOutput struct {
          
          	// The link association.
          	LinkAssociation *types.LinkAssociation
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type AssociateTransitGatewayConnectPeerInput

          type AssociateTransitGatewayConnectPeerInput struct {
          
          	// The ID of the device.
          	//
          	// This member is required.
          	DeviceId *string
          
          	// The ID of the global network.
          	//
          	// This member is required.
          	GlobalNetworkId *string
          
          	// The Amazon Resource Name (ARN) of the Connect peer.
          	//
          	// This member is required.
          	TransitGatewayConnectPeerArn *string
          
          	// The ID of the link.
          	LinkId *string
          }

          type AssociateTransitGatewayConnectPeerOutput

          type AssociateTransitGatewayConnectPeerOutput struct {
          
          	// The transit gateway Connect peer association.
          	TransitGatewayConnectPeerAssociation *types.TransitGatewayConnectPeerAssociation
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type Client

          type Client struct {
          	// contains filtered or unexported fields
          }

            Client provides the API client to make operations call for AWS Network Manager.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) AssociateCustomerGateway

                func (c *Client) AssociateCustomerGateway(ctx context.Context, params *AssociateCustomerGatewayInput, optFns ...func(*Options)) (*AssociateCustomerGatewayOutput, error)

                  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. The transit gateway must be registered in your global network. When you register a transit gateway, 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 (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpnConnections.html) EC2 API and filter by transit-gateway-id. You cannot associate a customer gateway with more than one device and link.

                  func (c *Client) AssociateLink(ctx context.Context, params *AssociateLinkInput, optFns ...func(*Options)) (*AssociateLinkOutput, error)

                    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.

                    func (*Client) AssociateTransitGatewayConnectPeer

                    func (c *Client) AssociateTransitGatewayConnectPeer(ctx context.Context, params *AssociateTransitGatewayConnectPeerInput, optFns ...func(*Options)) (*AssociateTransitGatewayConnectPeerOutput, error)

                      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.

                      func (*Client) CreateConnection

                      func (c *Client) CreateConnection(ctx context.Context, params *CreateConnectionInput, optFns ...func(*Options)) (*CreateConnectionOutput, error)

                        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.

                        func (*Client) CreateDevice

                        func (c *Client) CreateDevice(ctx context.Context, params *CreateDeviceInput, optFns ...func(*Options)) (*CreateDeviceOutput, error)

                          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.

                          func (*Client) CreateGlobalNetwork

                          func (c *Client) CreateGlobalNetwork(ctx context.Context, params *CreateGlobalNetworkInput, optFns ...func(*Options)) (*CreateGlobalNetworkOutput, error)

                            Creates a new, empty global network.

                            func (c *Client) CreateLink(ctx context.Context, params *CreateLinkInput, optFns ...func(*Options)) (*CreateLinkOutput, error)

                              Creates a new link for a specified site.

                              func (*Client) CreateSite

                              func (c *Client) CreateSite(ctx context.Context, params *CreateSiteInput, optFns ...func(*Options)) (*CreateSiteOutput, error)

                                Creates a new site in a global network.

                                func (*Client) DeleteConnection

                                func (c *Client) DeleteConnection(ctx context.Context, params *DeleteConnectionInput, optFns ...func(*Options)) (*DeleteConnectionOutput, error)

                                  Deletes the specified connection in your global network.

                                  func (*Client) DeleteDevice

                                  func (c *Client) DeleteDevice(ctx context.Context, params *DeleteDeviceInput, optFns ...func(*Options)) (*DeleteDeviceOutput, error)

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

                                    func (*Client) DeleteGlobalNetwork

                                    func (c *Client) DeleteGlobalNetwork(ctx context.Context, params *DeleteGlobalNetworkInput, optFns ...func(*Options)) (*DeleteGlobalNetworkOutput, error)

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

                                      func (c *Client) DeleteLink(ctx context.Context, params *DeleteLinkInput, optFns ...func(*Options)) (*DeleteLinkOutput, error)

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

                                        func (*Client) DeleteSite

                                        func (c *Client) DeleteSite(ctx context.Context, params *DeleteSiteInput, optFns ...func(*Options)) (*DeleteSiteOutput, error)

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

                                          func (*Client) DeregisterTransitGateway

                                          func (c *Client) DeregisterTransitGateway(ctx context.Context, params *DeregisterTransitGatewayInput, optFns ...func(*Options)) (*DeregisterTransitGatewayOutput, error)

                                            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.

                                            func (*Client) DescribeGlobalNetworks

                                            func (c *Client) DescribeGlobalNetworks(ctx context.Context, params *DescribeGlobalNetworksInput, optFns ...func(*Options)) (*DescribeGlobalNetworksOutput, error)

                                              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.

                                              func (*Client) DisassociateCustomerGateway

                                              func (c *Client) DisassociateCustomerGateway(ctx context.Context, params *DisassociateCustomerGatewayInput, optFns ...func(*Options)) (*DisassociateCustomerGatewayOutput, error)

                                                Disassociates a customer gateway from a device and a link.

                                                func (c *Client) DisassociateLink(ctx context.Context, params *DisassociateLinkInput, optFns ...func(*Options)) (*DisassociateLinkOutput, error)

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

                                                  func (*Client) DisassociateTransitGatewayConnectPeer

                                                  func (c *Client) DisassociateTransitGatewayConnectPeer(ctx context.Context, params *DisassociateTransitGatewayConnectPeerInput, optFns ...func(*Options)) (*DisassociateTransitGatewayConnectPeerOutput, error)

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

                                                    func (*Client) GetConnections

                                                    func (c *Client) GetConnections(ctx context.Context, params *GetConnectionsInput, optFns ...func(*Options)) (*GetConnectionsOutput, error)

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

                                                      func (*Client) GetCustomerGatewayAssociations

                                                      func (c *Client) GetCustomerGatewayAssociations(ctx context.Context, params *GetCustomerGatewayAssociationsInput, optFns ...func(*Options)) (*GetCustomerGatewayAssociationsOutput, error)

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

                                                        func (*Client) GetDevices

                                                        func (c *Client) GetDevices(ctx context.Context, params *GetDevicesInput, optFns ...func(*Options)) (*GetDevicesOutput, error)

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

                                                          func (*Client) GetLinkAssociations

                                                          func (c *Client) GetLinkAssociations(ctx context.Context, params *GetLinkAssociationsInput, optFns ...func(*Options)) (*GetLinkAssociationsOutput, error)

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

                                                            func (c *Client) GetLinks(ctx context.Context, params *GetLinksInput, optFns ...func(*Options)) (*GetLinksOutput, error)

                                                              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.

                                                              func (*Client) GetSites

                                                              func (c *Client) GetSites(ctx context.Context, params *GetSitesInput, optFns ...func(*Options)) (*GetSitesOutput, error)

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

                                                                func (*Client) GetTransitGatewayConnectPeerAssociations

                                                                func (c *Client) GetTransitGatewayConnectPeerAssociations(ctx context.Context, params *GetTransitGatewayConnectPeerAssociationsInput, optFns ...func(*Options)) (*GetTransitGatewayConnectPeerAssociationsOutput, error)

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

                                                                  func (*Client) GetTransitGatewayRegistrations

                                                                  func (c *Client) GetTransitGatewayRegistrations(ctx context.Context, params *GetTransitGatewayRegistrationsInput, optFns ...func(*Options)) (*GetTransitGatewayRegistrationsOutput, error)

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

                                                                    func (*Client) ListTagsForResource

                                                                    func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                                      Lists the tags for a specified resource.

                                                                      func (*Client) RegisterTransitGateway

                                                                      func (c *Client) RegisterTransitGateway(ctx context.Context, params *RegisterTransitGatewayInput, optFns ...func(*Options)) (*RegisterTransitGatewayOutput, error)

                                                                        Registers a transit gateway in your global network. The transit gateway can be in any AWS Region, but it must be owned by the same AWS account that owns the global network. You cannot register a transit gateway in more than one global network.

                                                                        func (*Client) TagResource

                                                                        func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                                                          Tags a specified resource.

                                                                          func (*Client) UntagResource

                                                                          func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                                            Removes tags from a specified resource.

                                                                            func (*Client) UpdateConnection

                                                                            func (c *Client) UpdateConnection(ctx context.Context, params *UpdateConnectionInput, optFns ...func(*Options)) (*UpdateConnectionOutput, error)

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

                                                                              func (*Client) UpdateDevice

                                                                              func (c *Client) UpdateDevice(ctx context.Context, params *UpdateDeviceInput, optFns ...func(*Options)) (*UpdateDeviceOutput, error)

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

                                                                                func (*Client) UpdateGlobalNetwork

                                                                                func (c *Client) UpdateGlobalNetwork(ctx context.Context, params *UpdateGlobalNetworkInput, optFns ...func(*Options)) (*UpdateGlobalNetworkOutput, error)

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

                                                                                  func (c *Client) UpdateLink(ctx context.Context, params *UpdateLinkInput, optFns ...func(*Options)) (*UpdateLinkOutput, error)

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

                                                                                    func (*Client) UpdateSite

                                                                                    func (c *Client) UpdateSite(ctx context.Context, params *UpdateSiteInput, optFns ...func(*Options)) (*UpdateSiteOutput, error)

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

                                                                                      type CreateConnectionInput

                                                                                      type CreateConnectionInput struct {
                                                                                      
                                                                                      	// The ID of the second device in the connection.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	ConnectedDeviceId *string
                                                                                      
                                                                                      	// The ID of the first device in the connection.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	DeviceId *string
                                                                                      
                                                                                      	// The ID of the global network.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	GlobalNetworkId *string
                                                                                      
                                                                                      	// The ID of the link for the second device.
                                                                                      	ConnectedLinkId *string
                                                                                      
                                                                                      	// A description of the connection. Length Constraints: Maximum length of 256
                                                                                      	// characters.
                                                                                      	Description *string
                                                                                      
                                                                                      	// The ID of the link for the first device.
                                                                                      	LinkId *string
                                                                                      
                                                                                      	// The tags to apply to the resource during creation.
                                                                                      	Tags []types.Tag
                                                                                      }

                                                                                      type CreateConnectionOutput

                                                                                      type CreateConnectionOutput struct {
                                                                                      
                                                                                      	// Information about the connection.
                                                                                      	Connection *types.Connection
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type CreateDeviceInput

                                                                                      type CreateDeviceInput struct {
                                                                                      
                                                                                      	// The ID of the global network.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	GlobalNetworkId *string
                                                                                      
                                                                                      	// The AWS location of the device.
                                                                                      	AWSLocation *types.AWSLocation
                                                                                      
                                                                                      	// A description of the device. Length Constraints: Maximum length of 256
                                                                                      	// characters.
                                                                                      	Description *string
                                                                                      
                                                                                      	// The location of the device.
                                                                                      	Location *types.Location
                                                                                      
                                                                                      	// The model of the device. Length Constraints: Maximum length of 128 characters.
                                                                                      	Model *string
                                                                                      
                                                                                      	// The serial number of the device. Length Constraints: Maximum length of 128
                                                                                      	// characters.
                                                                                      	SerialNumber *string
                                                                                      
                                                                                      	// The ID of the site.
                                                                                      	SiteId *string
                                                                                      
                                                                                      	// The tags to apply to the resource during creation.
                                                                                      	Tags []types.Tag
                                                                                      
                                                                                      	// The type of the device.
                                                                                      	Type *string
                                                                                      
                                                                                      	// The vendor of the device. Length Constraints: Maximum length of 128 characters.
                                                                                      	Vendor *string
                                                                                      }

                                                                                      type CreateDeviceOutput

                                                                                      type CreateDeviceOutput struct {
                                                                                      
                                                                                      	// Information about the device.
                                                                                      	Device *types.Device
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type CreateGlobalNetworkInput

                                                                                      type CreateGlobalNetworkInput struct {
                                                                                      
                                                                                      	// A description of the global network. Length Constraints: Maximum length of 256
                                                                                      	// characters.
                                                                                      	Description *string
                                                                                      
                                                                                      	// The tags to apply to the resource during creation.
                                                                                      	Tags []types.Tag
                                                                                      }

                                                                                      type CreateGlobalNetworkOutput

                                                                                      type CreateGlobalNetworkOutput struct {
                                                                                      
                                                                                      	// Information about the global network object.
                                                                                      	GlobalNetwork *types.GlobalNetwork
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type CreateLinkInput

                                                                                      type CreateLinkInput struct {
                                                                                      
                                                                                      	// The upload speed and download speed in Mbps.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	Bandwidth *types.Bandwidth
                                                                                      
                                                                                      	// The ID of the global network.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	GlobalNetworkId *string
                                                                                      
                                                                                      	// The ID of the site.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	SiteId *string
                                                                                      
                                                                                      	// A description of the link. Length Constraints: Maximum length of 256 characters.
                                                                                      	Description *string
                                                                                      
                                                                                      	// The provider of the link. Constraints: Cannot include the following characters:
                                                                                      	// | \ ^ Length Constraints: Maximum length of 128 characters.
                                                                                      	Provider *string
                                                                                      
                                                                                      	// The tags to apply to the resource during creation.
                                                                                      	Tags []types.Tag
                                                                                      
                                                                                      	// The type of the link. Constraints: Cannot include the following characters: | \
                                                                                      	// ^ Length Constraints: Maximum length of 128 characters.
                                                                                      	Type *string
                                                                                      }

                                                                                      type CreateLinkOutput

                                                                                      type CreateLinkOutput struct {
                                                                                      
                                                                                      	// Information about the link.
                                                                                      	Link *types.Link
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type CreateSiteInput

                                                                                      type CreateSiteInput struct {
                                                                                      
                                                                                      	// The ID of the global network.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	GlobalNetworkId *string
                                                                                      
                                                                                      	// A description of your site. Length Constraints: Maximum length of 256
                                                                                      	// characters.
                                                                                      	Description *string
                                                                                      
                                                                                      	// The site location. This information is used for visualization in the Network
                                                                                      	// Manager console. If you specify the address, the latitude and longitude are
                                                                                      	// automatically calculated.
                                                                                      	//
                                                                                      	// * Address: The physical address of the site.
                                                                                      	//
                                                                                      	// *
                                                                                      	// Latitude: The latitude of the site.
                                                                                      	//
                                                                                      	// * Longitude: The longitude of the site.
                                                                                      	Location *types.Location
                                                                                      
                                                                                      	// The tags to apply to the resource during creation.
                                                                                      	Tags []types.Tag
                                                                                      }

                                                                                      type CreateSiteOutput

                                                                                      type CreateSiteOutput struct {
                                                                                      
                                                                                      	// Information about the site.
                                                                                      	Site *types.Site
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type DeleteConnectionInput

                                                                                      type DeleteConnectionInput struct {
                                                                                      
                                                                                      	// The ID of the connection.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	ConnectionId *string
                                                                                      
                                                                                      	// The ID of the global network.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	GlobalNetworkId *string
                                                                                      }

                                                                                      type DeleteConnectionOutput

                                                                                      type DeleteConnectionOutput struct {
                                                                                      
                                                                                      	// Information about the connection.
                                                                                      	Connection *types.Connection
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type DeleteDeviceInput

                                                                                      type DeleteDeviceInput struct {
                                                                                      
                                                                                      	// The ID of the device.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	DeviceId *string
                                                                                      
                                                                                      	// The ID of the global network.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	GlobalNetworkId *string
                                                                                      }

                                                                                      type DeleteDeviceOutput

                                                                                      type DeleteDeviceOutput struct {
                                                                                      
                                                                                      	// Information about the device.
                                                                                      	Device *types.Device
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type DeleteGlobalNetworkInput

                                                                                      type DeleteGlobalNetworkInput struct {
                                                                                      
                                                                                      	// The ID of the global network.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	GlobalNetworkId *string
                                                                                      }

                                                                                      type DeleteGlobalNetworkOutput

                                                                                      type DeleteGlobalNetworkOutput struct {
                                                                                      
                                                                                      	// Information about the global network.
                                                                                      	GlobalNetwork *types.GlobalNetwork
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type DeleteLinkInput

                                                                                      type DeleteLinkInput struct {
                                                                                      
                                                                                      	// The ID of the global network.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	GlobalNetworkId *string
                                                                                      
                                                                                      	// The ID of the link.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	LinkId *string
                                                                                      }

                                                                                      type DeleteLinkOutput

                                                                                      type DeleteLinkOutput struct {
                                                                                      
                                                                                      	// Information about the link.
                                                                                      	Link *types.Link
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type DeleteSiteInput

                                                                                      type DeleteSiteInput struct {
                                                                                      
                                                                                      	// The ID of the global network.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	GlobalNetworkId *string
                                                                                      
                                                                                      	// The ID of the site.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	SiteId *string
                                                                                      }

                                                                                      type DeleteSiteOutput

                                                                                      type DeleteSiteOutput struct {
                                                                                      
                                                                                      	// Information about the site.
                                                                                      	Site *types.Site
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type DeregisterTransitGatewayInput

                                                                                      type DeregisterTransitGatewayInput struct {
                                                                                      
                                                                                      	// The ID of the global network.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	GlobalNetworkId *string
                                                                                      
                                                                                      	// The Amazon Resource Name (ARN) of the transit gateway.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	TransitGatewayArn *string
                                                                                      }

                                                                                      type DeregisterTransitGatewayOutput

                                                                                      type DeregisterTransitGatewayOutput struct {
                                                                                      
                                                                                      	// The transit gateway registration information.
                                                                                      	TransitGatewayRegistration *types.TransitGatewayRegistration
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type DescribeGlobalNetworksAPIClient

                                                                                      type DescribeGlobalNetworksAPIClient interface {
                                                                                      	DescribeGlobalNetworks(context.Context, *DescribeGlobalNetworksInput, ...func(*Options)) (*DescribeGlobalNetworksOutput, error)
                                                                                      }

                                                                                        DescribeGlobalNetworksAPIClient is a client that implements the DescribeGlobalNetworks operation.

                                                                                        type DescribeGlobalNetworksInput

                                                                                        type DescribeGlobalNetworksInput struct {
                                                                                        
                                                                                        	// The IDs of one or more global networks. The maximum is 10.
                                                                                        	GlobalNetworkIds []string
                                                                                        
                                                                                        	// The maximum number of results to return.
                                                                                        	MaxResults *int32
                                                                                        
                                                                                        	// The token for the next page of results.
                                                                                        	NextToken *string
                                                                                        }

                                                                                        type DescribeGlobalNetworksOutput

                                                                                        type DescribeGlobalNetworksOutput struct {
                                                                                        
                                                                                        	// Information about the global networks.
                                                                                        	GlobalNetworks []types.GlobalNetwork
                                                                                        
                                                                                        	// The token for the next page of results.
                                                                                        	NextToken *string
                                                                                        
                                                                                        	// Metadata pertaining to the operation's result.
                                                                                        	ResultMetadata middleware.Metadata
                                                                                        }

                                                                                        type DescribeGlobalNetworksPaginator

                                                                                        type DescribeGlobalNetworksPaginator struct {
                                                                                        	// contains filtered or unexported fields
                                                                                        }

                                                                                          DescribeGlobalNetworksPaginator is a paginator for DescribeGlobalNetworks

                                                                                          func NewDescribeGlobalNetworksPaginator

                                                                                            NewDescribeGlobalNetworksPaginator returns a new DescribeGlobalNetworksPaginator

                                                                                            func (*DescribeGlobalNetworksPaginator) HasMorePages

                                                                                            func (p *DescribeGlobalNetworksPaginator) HasMorePages() bool

                                                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                                                              func (*DescribeGlobalNetworksPaginator) NextPage

                                                                                                NextPage retrieves the next DescribeGlobalNetworks page.

                                                                                                type DescribeGlobalNetworksPaginatorOptions

                                                                                                type DescribeGlobalNetworksPaginatorOptions struct {
                                                                                                	// The maximum number of results to return.
                                                                                                	Limit int32
                                                                                                
                                                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                	// that matches the most recent token provided to the service.
                                                                                                	StopOnDuplicateToken bool
                                                                                                }

                                                                                                  DescribeGlobalNetworksPaginatorOptions is the paginator options for DescribeGlobalNetworks

                                                                                                  type DisassociateCustomerGatewayInput

                                                                                                  type DisassociateCustomerGatewayInput struct {
                                                                                                  
                                                                                                  	// The Amazon Resource Name (ARN) of the customer gateway. For more information,
                                                                                                  	// see Resources Defined by Amazon EC2
                                                                                                  	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonec2.html#amazonec2-resources-for-iam-policies).
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	CustomerGatewayArn *string
                                                                                                  
                                                                                                  	// The ID of the global network.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	GlobalNetworkId *string
                                                                                                  }

                                                                                                  type DisassociateCustomerGatewayOutput

                                                                                                  type DisassociateCustomerGatewayOutput struct {
                                                                                                  
                                                                                                  	// Information about the customer gateway association.
                                                                                                  	CustomerGatewayAssociation *types.CustomerGatewayAssociation
                                                                                                  
                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                  }

                                                                                                  type DisassociateLinkInput

                                                                                                  type DisassociateLinkInput struct {
                                                                                                  
                                                                                                  	// The ID of the device.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	DeviceId *string
                                                                                                  
                                                                                                  	// The ID of the global network.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	GlobalNetworkId *string
                                                                                                  
                                                                                                  	// The ID of the link.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	LinkId *string
                                                                                                  }

                                                                                                  type DisassociateLinkOutput

                                                                                                  type DisassociateLinkOutput struct {
                                                                                                  
                                                                                                  	// Information about the link association.
                                                                                                  	LinkAssociation *types.LinkAssociation
                                                                                                  
                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                  }

                                                                                                  type DisassociateTransitGatewayConnectPeerInput

                                                                                                  type DisassociateTransitGatewayConnectPeerInput struct {
                                                                                                  
                                                                                                  	// The ID of the global network.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	GlobalNetworkId *string
                                                                                                  
                                                                                                  	// The Amazon Resource Name (ARN) of the transit gateway Connect peer.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	TransitGatewayConnectPeerArn *string
                                                                                                  }

                                                                                                  type DisassociateTransitGatewayConnectPeerOutput

                                                                                                  type DisassociateTransitGatewayConnectPeerOutput struct {
                                                                                                  
                                                                                                  	// The transit gateway Connect peer association.
                                                                                                  	TransitGatewayConnectPeerAssociation *types.TransitGatewayConnectPeerAssociation
                                                                                                  
                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                  }

                                                                                                  type EndpointResolver

                                                                                                  type EndpointResolver interface {
                                                                                                  	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                                                                  }

                                                                                                    EndpointResolver interface for resolving service endpoints.

                                                                                                    func EndpointResolverFromURL

                                                                                                    func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                                                      EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                                                      type EndpointResolverFunc

                                                                                                      type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                                                        EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                                                        func (EndpointResolverFunc) ResolveEndpoint

                                                                                                        func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                                                        type EndpointResolverOptions

                                                                                                        type EndpointResolverOptions = internalendpoints.Options

                                                                                                          EndpointResolverOptions is the service endpoint resolver options

                                                                                                          type GetConnectionsAPIClient

                                                                                                          type GetConnectionsAPIClient interface {
                                                                                                          	GetConnections(context.Context, *GetConnectionsInput, ...func(*Options)) (*GetConnectionsOutput, error)
                                                                                                          }

                                                                                                            GetConnectionsAPIClient is a client that implements the GetConnections operation.

                                                                                                            type GetConnectionsInput

                                                                                                            type GetConnectionsInput struct {
                                                                                                            
                                                                                                            	// The ID of the global network.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	GlobalNetworkId *string
                                                                                                            
                                                                                                            	// One or more connection IDs.
                                                                                                            	ConnectionIds []string
                                                                                                            
                                                                                                            	// The ID of the device.
                                                                                                            	DeviceId *string
                                                                                                            
                                                                                                            	// The maximum number of results to return.
                                                                                                            	MaxResults *int32
                                                                                                            
                                                                                                            	// The token for the next page of results.
                                                                                                            	NextToken *string
                                                                                                            }

                                                                                                            type GetConnectionsOutput

                                                                                                            type GetConnectionsOutput struct {
                                                                                                            
                                                                                                            	// Information about the connections.
                                                                                                            	Connections []types.Connection
                                                                                                            
                                                                                                            	// The token to use for the next page of results.
                                                                                                            	NextToken *string
                                                                                                            
                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                            }

                                                                                                            type GetConnectionsPaginator

                                                                                                            type GetConnectionsPaginator struct {
                                                                                                            	// contains filtered or unexported fields
                                                                                                            }

                                                                                                              GetConnectionsPaginator is a paginator for GetConnections

                                                                                                              func NewGetConnectionsPaginator

                                                                                                              func NewGetConnectionsPaginator(client GetConnectionsAPIClient, params *GetConnectionsInput, optFns ...func(*GetConnectionsPaginatorOptions)) *GetConnectionsPaginator

                                                                                                                NewGetConnectionsPaginator returns a new GetConnectionsPaginator

                                                                                                                func (*GetConnectionsPaginator) HasMorePages

                                                                                                                func (p *GetConnectionsPaginator) HasMorePages() bool

                                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                  func (*GetConnectionsPaginator) NextPage

                                                                                                                  func (p *GetConnectionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetConnectionsOutput, error)

                                                                                                                    NextPage retrieves the next GetConnections page.

                                                                                                                    type GetConnectionsPaginatorOptions

                                                                                                                    type GetConnectionsPaginatorOptions struct {
                                                                                                                    	// The maximum number of results to return.
                                                                                                                    	Limit int32
                                                                                                                    
                                                                                                                    	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                    	// that matches the most recent token provided to the service.
                                                                                                                    	StopOnDuplicateToken bool
                                                                                                                    }

                                                                                                                      GetConnectionsPaginatorOptions is the paginator options for GetConnections

                                                                                                                      type GetCustomerGatewayAssociationsAPIClient

                                                                                                                      type GetCustomerGatewayAssociationsAPIClient interface {
                                                                                                                      	GetCustomerGatewayAssociations(context.Context, *GetCustomerGatewayAssociationsInput, ...func(*Options)) (*GetCustomerGatewayAssociationsOutput, error)
                                                                                                                      }

                                                                                                                        GetCustomerGatewayAssociationsAPIClient is a client that implements the GetCustomerGatewayAssociations operation.

                                                                                                                        type GetCustomerGatewayAssociationsInput

                                                                                                                        type GetCustomerGatewayAssociationsInput struct {
                                                                                                                        
                                                                                                                        	// The ID of the global network.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	GlobalNetworkId *string
                                                                                                                        
                                                                                                                        	// One or more customer gateway Amazon Resource Names (ARNs). For more information,
                                                                                                                        	// see Resources Defined by Amazon EC2
                                                                                                                        	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonec2.html#amazonec2-resources-for-iam-policies).
                                                                                                                        	// The maximum is 10.
                                                                                                                        	CustomerGatewayArns []string
                                                                                                                        
                                                                                                                        	// The maximum number of results to return.
                                                                                                                        	MaxResults *int32
                                                                                                                        
                                                                                                                        	// The token for the next page of results.
                                                                                                                        	NextToken *string
                                                                                                                        }

                                                                                                                        type GetCustomerGatewayAssociationsOutput

                                                                                                                        type GetCustomerGatewayAssociationsOutput struct {
                                                                                                                        
                                                                                                                        	// The customer gateway associations.
                                                                                                                        	CustomerGatewayAssociations []types.CustomerGatewayAssociation
                                                                                                                        
                                                                                                                        	// The token for the next page of results.
                                                                                                                        	NextToken *string
                                                                                                                        
                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                        }

                                                                                                                        type GetCustomerGatewayAssociationsPaginator

                                                                                                                        type GetCustomerGatewayAssociationsPaginator struct {
                                                                                                                        	// contains filtered or unexported fields
                                                                                                                        }

                                                                                                                          GetCustomerGatewayAssociationsPaginator is a paginator for GetCustomerGatewayAssociations

                                                                                                                          func NewGetCustomerGatewayAssociationsPaginator

                                                                                                                            NewGetCustomerGatewayAssociationsPaginator returns a new GetCustomerGatewayAssociationsPaginator

                                                                                                                            func (*GetCustomerGatewayAssociationsPaginator) HasMorePages

                                                                                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                              func (*GetCustomerGatewayAssociationsPaginator) NextPage

                                                                                                                                NextPage retrieves the next GetCustomerGatewayAssociations page.

                                                                                                                                type GetCustomerGatewayAssociationsPaginatorOptions

                                                                                                                                type GetCustomerGatewayAssociationsPaginatorOptions struct {
                                                                                                                                	// The maximum number of results to return.
                                                                                                                                	Limit int32
                                                                                                                                
                                                                                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                	// that matches the most recent token provided to the service.
                                                                                                                                	StopOnDuplicateToken bool
                                                                                                                                }

                                                                                                                                  GetCustomerGatewayAssociationsPaginatorOptions is the paginator options for GetCustomerGatewayAssociations

                                                                                                                                  type GetDevicesAPIClient

                                                                                                                                  type GetDevicesAPIClient interface {
                                                                                                                                  	GetDevices(context.Context, *GetDevicesInput, ...func(*Options)) (*GetDevicesOutput, error)
                                                                                                                                  }

                                                                                                                                    GetDevicesAPIClient is a client that implements the GetDevices operation.

                                                                                                                                    type GetDevicesInput

                                                                                                                                    type GetDevicesInput struct {
                                                                                                                                    
                                                                                                                                    	// The ID of the global network.
                                                                                                                                    	//
                                                                                                                                    	// This member is required.
                                                                                                                                    	GlobalNetworkId *string
                                                                                                                                    
                                                                                                                                    	// One or more device IDs. The maximum is 10.
                                                                                                                                    	DeviceIds []string
                                                                                                                                    
                                                                                                                                    	// The maximum number of results to return.
                                                                                                                                    	MaxResults *int32
                                                                                                                                    
                                                                                                                                    	// The token for the next page of results.
                                                                                                                                    	NextToken *string
                                                                                                                                    
                                                                                                                                    	// The ID of the site.
                                                                                                                                    	SiteId *string
                                                                                                                                    }

                                                                                                                                    type GetDevicesOutput

                                                                                                                                    type GetDevicesOutput struct {
                                                                                                                                    
                                                                                                                                    	// The devices.
                                                                                                                                    	Devices []types.Device
                                                                                                                                    
                                                                                                                                    	// The token for the next page of results.
                                                                                                                                    	NextToken *string
                                                                                                                                    
                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                    }

                                                                                                                                    type GetDevicesPaginator

                                                                                                                                    type GetDevicesPaginator struct {
                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                    }

                                                                                                                                      GetDevicesPaginator is a paginator for GetDevices

                                                                                                                                      func NewGetDevicesPaginator

                                                                                                                                      func NewGetDevicesPaginator(client GetDevicesAPIClient, params *GetDevicesInput, optFns ...func(*GetDevicesPaginatorOptions)) *GetDevicesPaginator

                                                                                                                                        NewGetDevicesPaginator returns a new GetDevicesPaginator

                                                                                                                                        func (*GetDevicesPaginator) HasMorePages

                                                                                                                                        func (p *GetDevicesPaginator) HasMorePages() bool

                                                                                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                          func (*GetDevicesPaginator) NextPage

                                                                                                                                          func (p *GetDevicesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetDevicesOutput, error)

                                                                                                                                            NextPage retrieves the next GetDevices page.

                                                                                                                                            type GetDevicesPaginatorOptions

                                                                                                                                            type GetDevicesPaginatorOptions struct {
                                                                                                                                            	// The maximum number of results to return.
                                                                                                                                            	Limit int32
                                                                                                                                            
                                                                                                                                            	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                            	// that matches the most recent token provided to the service.
                                                                                                                                            	StopOnDuplicateToken bool
                                                                                                                                            }

                                                                                                                                              GetDevicesPaginatorOptions is the paginator options for GetDevices

                                                                                                                                              type GetLinkAssociationsAPIClient

                                                                                                                                              type GetLinkAssociationsAPIClient interface {
                                                                                                                                              	GetLinkAssociations(context.Context, *GetLinkAssociationsInput, ...func(*Options)) (*GetLinkAssociationsOutput, error)
                                                                                                                                              }

                                                                                                                                                GetLinkAssociationsAPIClient is a client that implements the GetLinkAssociations operation.

                                                                                                                                                type GetLinkAssociationsInput

                                                                                                                                                type GetLinkAssociationsInput struct {
                                                                                                                                                
                                                                                                                                                	// The ID of the global network.
                                                                                                                                                	//
                                                                                                                                                	// This member is required.
                                                                                                                                                	GlobalNetworkId *string
                                                                                                                                                
                                                                                                                                                	// The ID of the device.
                                                                                                                                                	DeviceId *string
                                                                                                                                                
                                                                                                                                                	// The ID of the link.
                                                                                                                                                	LinkId *string
                                                                                                                                                
                                                                                                                                                	// The maximum number of results to return.
                                                                                                                                                	MaxResults *int32
                                                                                                                                                
                                                                                                                                                	// The token for the next page of results.
                                                                                                                                                	NextToken *string
                                                                                                                                                }

                                                                                                                                                type GetLinkAssociationsOutput

                                                                                                                                                type GetLinkAssociationsOutput struct {
                                                                                                                                                
                                                                                                                                                	// The link associations.
                                                                                                                                                	LinkAssociations []types.LinkAssociation
                                                                                                                                                
                                                                                                                                                	// The token for the next page of results.
                                                                                                                                                	NextToken *string
                                                                                                                                                
                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                }

                                                                                                                                                type GetLinkAssociationsPaginator

                                                                                                                                                type GetLinkAssociationsPaginator struct {
                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                }

                                                                                                                                                  GetLinkAssociationsPaginator is a paginator for GetLinkAssociations

                                                                                                                                                  func NewGetLinkAssociationsPaginator

                                                                                                                                                  func NewGetLinkAssociationsPaginator(client GetLinkAssociationsAPIClient, params *GetLinkAssociationsInput, optFns ...func(*GetLinkAssociationsPaginatorOptions)) *GetLinkAssociationsPaginator

                                                                                                                                                    NewGetLinkAssociationsPaginator returns a new GetLinkAssociationsPaginator

                                                                                                                                                    func (*GetLinkAssociationsPaginator) HasMorePages

                                                                                                                                                    func (p *GetLinkAssociationsPaginator) HasMorePages() bool

                                                                                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                      func (*GetLinkAssociationsPaginator) NextPage

                                                                                                                                                      func (p *GetLinkAssociationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetLinkAssociationsOutput, error)

                                                                                                                                                        NextPage retrieves the next GetLinkAssociations page.

                                                                                                                                                        type GetLinkAssociationsPaginatorOptions

                                                                                                                                                        type GetLinkAssociationsPaginatorOptions struct {
                                                                                                                                                        	// The maximum number of results to return.
                                                                                                                                                        	Limit int32
                                                                                                                                                        
                                                                                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                        	// that matches the most recent token provided to the service.
                                                                                                                                                        	StopOnDuplicateToken bool
                                                                                                                                                        }

                                                                                                                                                          GetLinkAssociationsPaginatorOptions is the paginator options for GetLinkAssociations

                                                                                                                                                          type GetLinksAPIClient

                                                                                                                                                          type GetLinksAPIClient interface {
                                                                                                                                                          	GetLinks(context.Context, *GetLinksInput, ...func(*Options)) (*GetLinksOutput, error)
                                                                                                                                                          }

                                                                                                                                                            GetLinksAPIClient is a client that implements the GetLinks operation.

                                                                                                                                                            type GetLinksInput

                                                                                                                                                            type GetLinksInput struct {
                                                                                                                                                            
                                                                                                                                                            	// The ID of the global network.
                                                                                                                                                            	//
                                                                                                                                                            	// This member is required.
                                                                                                                                                            	GlobalNetworkId *string
                                                                                                                                                            
                                                                                                                                                            	// One or more link IDs. The maximum is 10.
                                                                                                                                                            	LinkIds []string
                                                                                                                                                            
                                                                                                                                                            	// The maximum number of results to return.
                                                                                                                                                            	MaxResults *int32
                                                                                                                                                            
                                                                                                                                                            	// The token for the next page of results.
                                                                                                                                                            	NextToken *string
                                                                                                                                                            
                                                                                                                                                            	// The link provider.
                                                                                                                                                            	Provider *string
                                                                                                                                                            
                                                                                                                                                            	// The ID of the site.
                                                                                                                                                            	SiteId *string
                                                                                                                                                            
                                                                                                                                                            	// The link type.
                                                                                                                                                            	Type *string
                                                                                                                                                            }

                                                                                                                                                            type GetLinksOutput

                                                                                                                                                            type GetLinksOutput struct {
                                                                                                                                                            
                                                                                                                                                            	// The links.
                                                                                                                                                            	Links []types.Link
                                                                                                                                                            
                                                                                                                                                            	// The token for the next page of results.
                                                                                                                                                            	NextToken *string
                                                                                                                                                            
                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                            }

                                                                                                                                                            type GetLinksPaginator

                                                                                                                                                            type GetLinksPaginator struct {
                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                            }

                                                                                                                                                              GetLinksPaginator is a paginator for GetLinks

                                                                                                                                                              func NewGetLinksPaginator

                                                                                                                                                              func NewGetLinksPaginator(client GetLinksAPIClient, params *GetLinksInput, optFns ...func(*GetLinksPaginatorOptions)) *GetLinksPaginator

                                                                                                                                                                NewGetLinksPaginator returns a new GetLinksPaginator

                                                                                                                                                                func (*GetLinksPaginator) HasMorePages

                                                                                                                                                                func (p *GetLinksPaginator) HasMorePages() bool

                                                                                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                  func (*GetLinksPaginator) NextPage

                                                                                                                                                                  func (p *GetLinksPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetLinksOutput, error)

                                                                                                                                                                    NextPage retrieves the next GetLinks page.

                                                                                                                                                                    type GetLinksPaginatorOptions

                                                                                                                                                                    type GetLinksPaginatorOptions struct {
                                                                                                                                                                    	// The maximum number of results to return.
                                                                                                                                                                    	Limit int32
                                                                                                                                                                    
                                                                                                                                                                    	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                    	// that matches the most recent token provided to the service.
                                                                                                                                                                    	StopOnDuplicateToken bool
                                                                                                                                                                    }

                                                                                                                                                                      GetLinksPaginatorOptions is the paginator options for GetLinks

                                                                                                                                                                      type GetSitesAPIClient

                                                                                                                                                                      type GetSitesAPIClient interface {
                                                                                                                                                                      	GetSites(context.Context, *GetSitesInput, ...func(*Options)) (*GetSitesOutput, error)
                                                                                                                                                                      }

                                                                                                                                                                        GetSitesAPIClient is a client that implements the GetSites operation.

                                                                                                                                                                        type GetSitesInput

                                                                                                                                                                        type GetSitesInput struct {
                                                                                                                                                                        
                                                                                                                                                                        	// The ID of the global network.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	GlobalNetworkId *string
                                                                                                                                                                        
                                                                                                                                                                        	// The maximum number of results to return.
                                                                                                                                                                        	MaxResults *int32
                                                                                                                                                                        
                                                                                                                                                                        	// The token for the next page of results.
                                                                                                                                                                        	NextToken *string
                                                                                                                                                                        
                                                                                                                                                                        	// One or more site IDs. The maximum is 10.
                                                                                                                                                                        	SiteIds []string
                                                                                                                                                                        }

                                                                                                                                                                        type GetSitesOutput

                                                                                                                                                                        type GetSitesOutput struct {
                                                                                                                                                                        
                                                                                                                                                                        	// The token for the next page of results.
                                                                                                                                                                        	NextToken *string
                                                                                                                                                                        
                                                                                                                                                                        	// The sites.
                                                                                                                                                                        	Sites []types.Site
                                                                                                                                                                        
                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                        }

                                                                                                                                                                        type GetSitesPaginator

                                                                                                                                                                        type GetSitesPaginator struct {
                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                        }

                                                                                                                                                                          GetSitesPaginator is a paginator for GetSites

                                                                                                                                                                          func NewGetSitesPaginator

                                                                                                                                                                          func NewGetSitesPaginator(client GetSitesAPIClient, params *GetSitesInput, optFns ...func(*GetSitesPaginatorOptions)) *GetSitesPaginator

                                                                                                                                                                            NewGetSitesPaginator returns a new GetSitesPaginator

                                                                                                                                                                            func (*GetSitesPaginator) HasMorePages

                                                                                                                                                                            func (p *GetSitesPaginator) HasMorePages() bool

                                                                                                                                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                              func (*GetSitesPaginator) NextPage

                                                                                                                                                                              func (p *GetSitesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetSitesOutput, error)

                                                                                                                                                                                NextPage retrieves the next GetSites page.

                                                                                                                                                                                type GetSitesPaginatorOptions

                                                                                                                                                                                type GetSitesPaginatorOptions struct {
                                                                                                                                                                                	// The maximum number of results to return.
                                                                                                                                                                                	Limit int32
                                                                                                                                                                                
                                                                                                                                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                	// that matches the most recent token provided to the service.
                                                                                                                                                                                	StopOnDuplicateToken bool
                                                                                                                                                                                }

                                                                                                                                                                                  GetSitesPaginatorOptions is the paginator options for GetSites

                                                                                                                                                                                  type GetTransitGatewayConnectPeerAssociationsAPIClient

                                                                                                                                                                                  type GetTransitGatewayConnectPeerAssociationsAPIClient interface {
                                                                                                                                                                                  	GetTransitGatewayConnectPeerAssociations(context.Context, *GetTransitGatewayConnectPeerAssociationsInput, ...func(*Options)) (*GetTransitGatewayConnectPeerAssociationsOutput, error)
                                                                                                                                                                                  }

                                                                                                                                                                                    GetTransitGatewayConnectPeerAssociationsAPIClient is a client that implements the GetTransitGatewayConnectPeerAssociations operation.

                                                                                                                                                                                    type GetTransitGatewayConnectPeerAssociationsInput

                                                                                                                                                                                    type GetTransitGatewayConnectPeerAssociationsInput struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The ID of the global network.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	GlobalNetworkId *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// The maximum number of results to return.
                                                                                                                                                                                    	MaxResults *int32
                                                                                                                                                                                    
                                                                                                                                                                                    	// The token for the next page of results.
                                                                                                                                                                                    	NextToken *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// One or more transit gateway Connect peer Amazon Resource Names (ARNs).
                                                                                                                                                                                    	TransitGatewayConnectPeerArns []string
                                                                                                                                                                                    }

                                                                                                                                                                                    type GetTransitGatewayConnectPeerAssociationsOutput

                                                                                                                                                                                    type GetTransitGatewayConnectPeerAssociationsOutput struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The token to use for the next page of results.
                                                                                                                                                                                    	NextToken *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// Information about the transit gateway Connect peer associations.
                                                                                                                                                                                    	TransitGatewayConnectPeerAssociations []types.TransitGatewayConnectPeerAssociation
                                                                                                                                                                                    
                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                    }

                                                                                                                                                                                    type GetTransitGatewayConnectPeerAssociationsPaginator

                                                                                                                                                                                    type GetTransitGatewayConnectPeerAssociationsPaginator struct {
                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                    }

                                                                                                                                                                                      GetTransitGatewayConnectPeerAssociationsPaginator is a paginator for GetTransitGatewayConnectPeerAssociations

                                                                                                                                                                                      func NewGetTransitGatewayConnectPeerAssociationsPaginator

                                                                                                                                                                                        NewGetTransitGatewayConnectPeerAssociationsPaginator returns a new GetTransitGatewayConnectPeerAssociationsPaginator

                                                                                                                                                                                        func (*GetTransitGatewayConnectPeerAssociationsPaginator) HasMorePages

                                                                                                                                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                          func (*GetTransitGatewayConnectPeerAssociationsPaginator) NextPage

                                                                                                                                                                                            NextPage retrieves the next GetTransitGatewayConnectPeerAssociations page.

                                                                                                                                                                                            type GetTransitGatewayConnectPeerAssociationsPaginatorOptions

                                                                                                                                                                                            type GetTransitGatewayConnectPeerAssociationsPaginatorOptions struct {
                                                                                                                                                                                            	// The maximum number of results to return.
                                                                                                                                                                                            	Limit int32
                                                                                                                                                                                            
                                                                                                                                                                                            	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                            	// that matches the most recent token provided to the service.
                                                                                                                                                                                            	StopOnDuplicateToken bool
                                                                                                                                                                                            }

                                                                                                                                                                                              GetTransitGatewayConnectPeerAssociationsPaginatorOptions is the paginator options for GetTransitGatewayConnectPeerAssociations

                                                                                                                                                                                              type GetTransitGatewayRegistrationsAPIClient

                                                                                                                                                                                              type GetTransitGatewayRegistrationsAPIClient interface {
                                                                                                                                                                                              	GetTransitGatewayRegistrations(context.Context, *GetTransitGatewayRegistrationsInput, ...func(*Options)) (*GetTransitGatewayRegistrationsOutput, error)
                                                                                                                                                                                              }

                                                                                                                                                                                                GetTransitGatewayRegistrationsAPIClient is a client that implements the GetTransitGatewayRegistrations operation.

                                                                                                                                                                                                type GetTransitGatewayRegistrationsInput

                                                                                                                                                                                                type GetTransitGatewayRegistrationsInput struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The ID of the global network.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	GlobalNetworkId *string
                                                                                                                                                                                                
                                                                                                                                                                                                	// The maximum number of results to return.
                                                                                                                                                                                                	MaxResults *int32
                                                                                                                                                                                                
                                                                                                                                                                                                	// The token for the next page of results.
                                                                                                                                                                                                	NextToken *string
                                                                                                                                                                                                
                                                                                                                                                                                                	// The Amazon Resource Names (ARNs) of one or more transit gateways. The maximum is
                                                                                                                                                                                                	// 10.
                                                                                                                                                                                                	TransitGatewayArns []string
                                                                                                                                                                                                }

                                                                                                                                                                                                type GetTransitGatewayRegistrationsOutput

                                                                                                                                                                                                type GetTransitGatewayRegistrationsOutput struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The token for the next page of results.
                                                                                                                                                                                                	NextToken *string
                                                                                                                                                                                                
                                                                                                                                                                                                	// The transit gateway registrations.
                                                                                                                                                                                                	TransitGatewayRegistrations []types.TransitGatewayRegistration
                                                                                                                                                                                                
                                                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                                                }

                                                                                                                                                                                                type GetTransitGatewayRegistrationsPaginator

                                                                                                                                                                                                type GetTransitGatewayRegistrationsPaginator struct {
                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                }

                                                                                                                                                                                                  GetTransitGatewayRegistrationsPaginator is a paginator for GetTransitGatewayRegistrations

                                                                                                                                                                                                  func NewGetTransitGatewayRegistrationsPaginator

                                                                                                                                                                                                    NewGetTransitGatewayRegistrationsPaginator returns a new GetTransitGatewayRegistrationsPaginator

                                                                                                                                                                                                    func (*GetTransitGatewayRegistrationsPaginator) HasMorePages

                                                                                                                                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                                      func (*GetTransitGatewayRegistrationsPaginator) NextPage

                                                                                                                                                                                                        NextPage retrieves the next GetTransitGatewayRegistrations page.

                                                                                                                                                                                                        type GetTransitGatewayRegistrationsPaginatorOptions

                                                                                                                                                                                                        type GetTransitGatewayRegistrationsPaginatorOptions struct {
                                                                                                                                                                                                        	// The maximum number of results to return.
                                                                                                                                                                                                        	Limit int32
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                                        	// that matches the most recent token provided to the service.
                                                                                                                                                                                                        	StopOnDuplicateToken bool
                                                                                                                                                                                                        }

                                                                                                                                                                                                          GetTransitGatewayRegistrationsPaginatorOptions is the paginator options for GetTransitGatewayRegistrations

                                                                                                                                                                                                          type HTTPClient

                                                                                                                                                                                                          type HTTPClient interface {
                                                                                                                                                                                                          	Do(*http.Request) (*http.Response, error)
                                                                                                                                                                                                          }

                                                                                                                                                                                                          type HTTPSignerV4

                                                                                                                                                                                                          type HTTPSignerV4 interface {
                                                                                                                                                                                                          	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                                                                                                                                                          }

                                                                                                                                                                                                          type ListTagsForResourceInput

                                                                                                                                                                                                          type ListTagsForResourceInput struct {
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the resource.
                                                                                                                                                                                                          	//
                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                          	ResourceArn *string
                                                                                                                                                                                                          }

                                                                                                                                                                                                          type ListTagsForResourceOutput

                                                                                                                                                                                                          type ListTagsForResourceOutput struct {
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The list of tags.
                                                                                                                                                                                                          	TagList []types.Tag
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                                          }

                                                                                                                                                                                                          type Options

                                                                                                                                                                                                          type Options struct {
                                                                                                                                                                                                          	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                                                                                                                          	// operations invoked for this client. Use functional options on operation call to
                                                                                                                                                                                                          	// modify this list for per operation behavior.
                                                                                                                                                                                                          	APIOptions []func(*middleware.Stack) error
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// Configures the events that will be sent to the configured logger.
                                                                                                                                                                                                          	ClientLogMode aws.ClientLogMode
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The credentials object to use when signing requests.
                                                                                                                                                                                                          	Credentials aws.CredentialsProvider
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                                                                                                                          	EndpointOptions EndpointResolverOptions
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The service endpoint resolver.
                                                                                                                                                                                                          	EndpointResolver EndpointResolver
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// Signature Version 4 (SigV4) Signer
                                                                                                                                                                                                          	HTTPSignerV4 HTTPSignerV4
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The logger writer interface to write logging messages to.
                                                                                                                                                                                                          	Logger logging.Logger
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The region to send requests to. (Required)
                                                                                                                                                                                                          	Region string
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                                                                                                                          	// failures. When nil the API client will use a default retryer.
                                                                                                                                                                                                          	Retryer aws.Retryer
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                                                                                                                          	// implementation if nil.
                                                                                                                                                                                                          	HTTPClient HTTPClient
                                                                                                                                                                                                          }

                                                                                                                                                                                                          func (Options) Copy

                                                                                                                                                                                                          func (o Options) Copy() Options

                                                                                                                                                                                                            Copy creates a clone where the APIOptions list is deep copied.

                                                                                                                                                                                                            type RegisterTransitGatewayInput

                                                                                                                                                                                                            type RegisterTransitGatewayInput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of the global network.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	GlobalNetworkId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) of the transit gateway. For more information, see
                                                                                                                                                                                                            	// Resources Defined by Amazon EC2
                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonec2.html#amazonec2-resources-for-iam-policies).
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	TransitGatewayArn *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type RegisterTransitGatewayOutput

                                                                                                                                                                                                            type RegisterTransitGatewayOutput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Information about the transit gateway registration.
                                                                                                                                                                                                            	TransitGatewayRegistration *types.TransitGatewayRegistration
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type ResolveEndpoint

                                                                                                                                                                                                            type ResolveEndpoint struct {
                                                                                                                                                                                                            	Resolver EndpointResolver
                                                                                                                                                                                                            	Options  EndpointResolverOptions
                                                                                                                                                                                                            }

                                                                                                                                                                                                            func (*ResolveEndpoint) HandleSerialize

                                                                                                                                                                                                            func (*ResolveEndpoint) ID

                                                                                                                                                                                                            func (*ResolveEndpoint) ID() string

                                                                                                                                                                                                            type TagResourceInput

                                                                                                                                                                                                            type TagResourceInput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) of the resource.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	ResourceArn *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The tags to apply to the specified resource.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	Tags []types.Tag
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type TagResourceOutput

                                                                                                                                                                                                            type TagResourceOutput struct {
                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UntagResourceInput

                                                                                                                                                                                                            type UntagResourceInput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) of the resource.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	ResourceArn *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The tag keys to remove from the specified resource.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	TagKeys []string
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UntagResourceOutput

                                                                                                                                                                                                            type UntagResourceOutput struct {
                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UpdateConnectionInput

                                                                                                                                                                                                            type UpdateConnectionInput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of the connection.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	ConnectionId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of the global network.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	GlobalNetworkId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of the link for the second device in the connection.
                                                                                                                                                                                                            	ConnectedLinkId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// A description of the connection. Length Constraints: Maximum length of 256
                                                                                                                                                                                                            	// characters.
                                                                                                                                                                                                            	Description *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of the link for the first device in the connection.
                                                                                                                                                                                                            	LinkId *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UpdateConnectionOutput

                                                                                                                                                                                                            type UpdateConnectionOutput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Information about the connection.
                                                                                                                                                                                                            	Connection *types.Connection
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UpdateDeviceInput

                                                                                                                                                                                                            type UpdateDeviceInput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of the device.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	DeviceId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of the global network.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	GlobalNetworkId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The AWS location of the device.
                                                                                                                                                                                                            	AWSLocation *types.AWSLocation
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// A description of the device. Length Constraints: Maximum length of 256
                                                                                                                                                                                                            	// characters.
                                                                                                                                                                                                            	Description *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Describes a location.
                                                                                                                                                                                                            	Location *types.Location
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The model of the device. Length Constraints: Maximum length of 128 characters.
                                                                                                                                                                                                            	Model *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The serial number of the device. Length Constraints: Maximum length of 128
                                                                                                                                                                                                            	// characters.
                                                                                                                                                                                                            	SerialNumber *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of the site.
                                                                                                                                                                                                            	SiteId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The type of the device.
                                                                                                                                                                                                            	Type *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The vendor of the device. Length Constraints: Maximum length of 128 characters.
                                                                                                                                                                                                            	Vendor *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UpdateDeviceOutput

                                                                                                                                                                                                            type UpdateDeviceOutput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Information about the device.
                                                                                                                                                                                                            	Device *types.Device
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UpdateGlobalNetworkInput

                                                                                                                                                                                                            type UpdateGlobalNetworkInput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of your global network.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	GlobalNetworkId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// A description of the global network. Length Constraints: Maximum length of 256
                                                                                                                                                                                                            	// characters.
                                                                                                                                                                                                            	Description *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UpdateGlobalNetworkOutput

                                                                                                                                                                                                            type UpdateGlobalNetworkOutput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Information about the global network object.
                                                                                                                                                                                                            	GlobalNetwork *types.GlobalNetwork
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UpdateLinkInput

                                                                                                                                                                                                            type UpdateLinkInput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of the global network.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	GlobalNetworkId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of the link.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	LinkId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The upload and download speed in Mbps.
                                                                                                                                                                                                            	Bandwidth *types.Bandwidth
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// A description of the link. Length Constraints: Maximum length of 256 characters.
                                                                                                                                                                                                            	Description *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The provider of the link. Length Constraints: Maximum length of 128 characters.
                                                                                                                                                                                                            	Provider *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The type of the link. Length Constraints: Maximum length of 128 characters.
                                                                                                                                                                                                            	Type *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UpdateLinkOutput

                                                                                                                                                                                                            type UpdateLinkOutput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Information about the link.
                                                                                                                                                                                                            	Link *types.Link
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UpdateSiteInput

                                                                                                                                                                                                            type UpdateSiteInput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of the global network.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	GlobalNetworkId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The ID of your site.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	SiteId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// A description of your site. Length Constraints: Maximum length of 256
                                                                                                                                                                                                            	// characters.
                                                                                                                                                                                                            	Description *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The site location:
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// * Address: The physical address of the site.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// * Latitude:
                                                                                                                                                                                                            	// The latitude of the site.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// * Longitude: The longitude of the site.
                                                                                                                                                                                                            	Location *types.Location
                                                                                                                                                                                                            }

                                                                                                                                                                                                            type UpdateSiteOutput

                                                                                                                                                                                                            type UpdateSiteOutput struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Information about the site.
                                                                                                                                                                                                            	Site *types.Site
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                            }

                                                                                                                                                                                                            Directories

                                                                                                                                                                                                            Path Synopsis
                                                                                                                                                                                                            internal