Documentation

Overview

    Package appmesh provides the API client, operations, and parameter types for AWS App Mesh.

    AWS App Mesh is a service mesh based on the Envoy proxy that makes it easy to monitor and control microservices. App Mesh standardizes how your microservices communicate, giving you end-to-end visibility and helping to ensure high availability for your applications. App Mesh gives you consistent visibility and network traffic controls for every microservice in an application. You can use App Mesh with AWS Fargate, Amazon ECS, Amazon EKS, Kubernetes on AWS, and Amazon EC2. App Mesh supports microservice applications that use service discovery naming for their components. For more information about service discovery on Amazon ECS, see Service Discovery (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html) in the Amazon Elastic Container Service Developer Guide. Kubernetes kube-dns and coredns are supported. For more information, see DNS for Services and Pods (https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/) in the Kubernetes documentation.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2019-01-25"
    View Source
    const ServiceID = "App Mesh"

    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 Client

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

            Client provides the API client to make operations call for AWS App Mesh.

            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) CreateGatewayRoute

                func (c *Client) CreateGatewayRoute(ctx context.Context, params *CreateGatewayRouteInput, optFns ...func(*Options)) (*CreateGatewayRouteOutput, error)

                  Creates a gateway route. A gateway route is attached to a virtual gateway and routes traffic to an existing virtual service. If a route matches a request, it can distribute traffic to a target virtual service. For more information about gateway routes, see Gateway routes (https://docs.aws.amazon.com/app-mesh/latest/userguide/gateway-routes.html).

                  func (*Client) CreateMesh

                  func (c *Client) CreateMesh(ctx context.Context, params *CreateMeshInput, optFns ...func(*Options)) (*CreateMeshOutput, error)

                    Creates a service mesh. A service mesh is a logical boundary for network traffic between services that are represented by resources within the mesh. After you create your service mesh, you can create virtual services, virtual nodes, virtual routers, and routes to distribute traffic between the applications in your mesh. For more information about service meshes, see Service meshes (https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html).

                    func (*Client) CreateRoute

                    func (c *Client) CreateRoute(ctx context.Context, params *CreateRouteInput, optFns ...func(*Options)) (*CreateRouteOutput, error)

                      Creates a route that is associated with a virtual router. You can route several different protocols and define a retry policy for a route. Traffic can be routed to one or more virtual nodes. For more information about routes, see Routes (https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html).

                      func (*Client) CreateVirtualGateway

                      func (c *Client) CreateVirtualGateway(ctx context.Context, params *CreateVirtualGatewayInput, optFns ...func(*Options)) (*CreateVirtualGatewayOutput, error)

                        Creates a virtual gateway. A virtual gateway allows resources outside your mesh to communicate to resources that are inside your mesh. The virtual gateway represents an Envoy proxy running in an Amazon ECS task, in a Kubernetes service, or on an Amazon EC2 instance. Unlike a virtual node, which represents an Envoy running with an application, a virtual gateway represents Envoy deployed by itself. For more information about virtual gateways, see Virtual gateways (https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_gateways.html).

                        func (*Client) CreateVirtualNode

                        func (c *Client) CreateVirtualNode(ctx context.Context, params *CreateVirtualNodeInput, optFns ...func(*Options)) (*CreateVirtualNodeOutput, error)

                          Creates a virtual node within a service mesh. A virtual node acts as a logical pointer to a particular task group, such as an Amazon ECS service or a Kubernetes deployment. When you create a virtual node, you can specify the service discovery information for your task group, and whether the proxy running in a task group will communicate with other proxies using Transport Layer Security (TLS). You define a listener for any inbound traffic that your virtual node expects. Any virtual service that your virtual node expects to communicate to is specified as a backend. The response metadata for your new virtual node contains the arn that is associated with the virtual node. Set this value (either the full ARN or the truncated resource name: for example, mesh/default/virtualNode/simpleapp) as the APPMESH_VIRTUAL_NODE_NAME environment variable for your task group's Envoy proxy container in your task definition or pod spec. This is then mapped to the node.id and node.cluster Envoy parameters. If you require your Envoy stats or tracing to use a different name, you can override the node.cluster value that is set by APPMESH_VIRTUAL_NODE_NAME with the APPMESH_VIRTUAL_NODE_CLUSTER environment variable. For more information about virtual nodes, see Virtual nodes (https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html).

                          func (*Client) CreateVirtualRouter

                          func (c *Client) CreateVirtualRouter(ctx context.Context, params *CreateVirtualRouterInput, optFns ...func(*Options)) (*CreateVirtualRouterOutput, error)

                            Creates a virtual router within a service mesh. Specify a listener for any inbound traffic that your virtual router receives. Create a virtual router for each protocol and port that you need to route. Virtual routers handle traffic for one or more virtual services within your mesh. After you create your virtual router, create and associate routes for your virtual router that direct incoming requests to different virtual nodes. For more information about virtual routers, see Virtual routers (https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html).

                            func (*Client) CreateVirtualService

                            func (c *Client) CreateVirtualService(ctx context.Context, params *CreateVirtualServiceInput, optFns ...func(*Options)) (*CreateVirtualServiceOutput, error)

                              Creates a virtual service within a service mesh. A virtual service is an abstraction of a real service that is provided by a virtual node directly or indirectly by means of a virtual router. Dependent services call your virtual service by its virtualServiceName, and those requests are routed to the virtual node or virtual router that is specified as the provider for the virtual service. For more information about virtual services, see Virtual services (https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html).

                              func (*Client) DeleteGatewayRoute

                              func (c *Client) DeleteGatewayRoute(ctx context.Context, params *DeleteGatewayRouteInput, optFns ...func(*Options)) (*DeleteGatewayRouteOutput, error)

                                Deletes an existing gateway route.

                                func (*Client) DeleteMesh

                                func (c *Client) DeleteMesh(ctx context.Context, params *DeleteMeshInput, optFns ...func(*Options)) (*DeleteMeshOutput, error)

                                  Deletes an existing service mesh. You must delete all resources (virtual services, routes, virtual routers, and virtual nodes) in the service mesh before you can delete the mesh itself.

                                  func (*Client) DeleteRoute

                                  func (c *Client) DeleteRoute(ctx context.Context, params *DeleteRouteInput, optFns ...func(*Options)) (*DeleteRouteOutput, error)

                                    Deletes an existing route.

                                    func (*Client) DeleteVirtualGateway

                                    func (c *Client) DeleteVirtualGateway(ctx context.Context, params *DeleteVirtualGatewayInput, optFns ...func(*Options)) (*DeleteVirtualGatewayOutput, error)

                                      Deletes an existing virtual gateway. You cannot delete a virtual gateway if any gateway routes are associated to it.

                                      func (*Client) DeleteVirtualNode

                                      func (c *Client) DeleteVirtualNode(ctx context.Context, params *DeleteVirtualNodeInput, optFns ...func(*Options)) (*DeleteVirtualNodeOutput, error)

                                        Deletes an existing virtual node. You must delete any virtual services that list a virtual node as a service provider before you can delete the virtual node itself.

                                        func (*Client) DeleteVirtualRouter

                                        func (c *Client) DeleteVirtualRouter(ctx context.Context, params *DeleteVirtualRouterInput, optFns ...func(*Options)) (*DeleteVirtualRouterOutput, error)

                                          Deletes an existing virtual router. You must delete any routes associated with the virtual router before you can delete the router itself.

                                          func (*Client) DeleteVirtualService

                                          func (c *Client) DeleteVirtualService(ctx context.Context, params *DeleteVirtualServiceInput, optFns ...func(*Options)) (*DeleteVirtualServiceOutput, error)

                                            Deletes an existing virtual service.

                                            func (*Client) DescribeGatewayRoute

                                            func (c *Client) DescribeGatewayRoute(ctx context.Context, params *DescribeGatewayRouteInput, optFns ...func(*Options)) (*DescribeGatewayRouteOutput, error)

                                              Describes an existing gateway route.

                                              func (*Client) DescribeMesh

                                              func (c *Client) DescribeMesh(ctx context.Context, params *DescribeMeshInput, optFns ...func(*Options)) (*DescribeMeshOutput, error)

                                                Describes an existing service mesh.

                                                func (*Client) DescribeRoute

                                                func (c *Client) DescribeRoute(ctx context.Context, params *DescribeRouteInput, optFns ...func(*Options)) (*DescribeRouteOutput, error)

                                                  Describes an existing route.

                                                  func (*Client) DescribeVirtualGateway

                                                  func (c *Client) DescribeVirtualGateway(ctx context.Context, params *DescribeVirtualGatewayInput, optFns ...func(*Options)) (*DescribeVirtualGatewayOutput, error)

                                                    Describes an existing virtual gateway.

                                                    func (*Client) DescribeVirtualNode

                                                    func (c *Client) DescribeVirtualNode(ctx context.Context, params *DescribeVirtualNodeInput, optFns ...func(*Options)) (*DescribeVirtualNodeOutput, error)

                                                      Describes an existing virtual node.

                                                      func (*Client) DescribeVirtualRouter

                                                      func (c *Client) DescribeVirtualRouter(ctx context.Context, params *DescribeVirtualRouterInput, optFns ...func(*Options)) (*DescribeVirtualRouterOutput, error)

                                                        Describes an existing virtual router.

                                                        func (*Client) DescribeVirtualService

                                                        func (c *Client) DescribeVirtualService(ctx context.Context, params *DescribeVirtualServiceInput, optFns ...func(*Options)) (*DescribeVirtualServiceOutput, error)

                                                          Describes an existing virtual service.

                                                          func (*Client) ListGatewayRoutes

                                                          func (c *Client) ListGatewayRoutes(ctx context.Context, params *ListGatewayRoutesInput, optFns ...func(*Options)) (*ListGatewayRoutesOutput, error)

                                                            Returns a list of existing gateway routes that are associated to a virtual gateway.

                                                            func (*Client) ListMeshes

                                                            func (c *Client) ListMeshes(ctx context.Context, params *ListMeshesInput, optFns ...func(*Options)) (*ListMeshesOutput, error)

                                                              Returns a list of existing service meshes.

                                                              func (*Client) ListRoutes

                                                              func (c *Client) ListRoutes(ctx context.Context, params *ListRoutesInput, optFns ...func(*Options)) (*ListRoutesOutput, error)

                                                                Returns a list of existing routes in a service mesh.

                                                                func (*Client) ListTagsForResource

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

                                                                  List the tags for an App Mesh resource.

                                                                  func (*Client) ListVirtualGateways

                                                                  func (c *Client) ListVirtualGateways(ctx context.Context, params *ListVirtualGatewaysInput, optFns ...func(*Options)) (*ListVirtualGatewaysOutput, error)

                                                                    Returns a list of existing virtual gateways in a service mesh.

                                                                    func (*Client) ListVirtualNodes

                                                                    func (c *Client) ListVirtualNodes(ctx context.Context, params *ListVirtualNodesInput, optFns ...func(*Options)) (*ListVirtualNodesOutput, error)

                                                                      Returns a list of existing virtual nodes.

                                                                      func (*Client) ListVirtualRouters

                                                                      func (c *Client) ListVirtualRouters(ctx context.Context, params *ListVirtualRoutersInput, optFns ...func(*Options)) (*ListVirtualRoutersOutput, error)

                                                                        Returns a list of existing virtual routers in a service mesh.

                                                                        func (*Client) ListVirtualServices

                                                                        func (c *Client) ListVirtualServices(ctx context.Context, params *ListVirtualServicesInput, optFns ...func(*Options)) (*ListVirtualServicesOutput, error)

                                                                          Returns a list of existing virtual services in a service mesh.

                                                                          func (*Client) TagResource

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

                                                                            Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource aren't specified in the request parameters, they aren't changed. When a resource is deleted, the tags associated with that resource are also deleted.

                                                                            func (*Client) UntagResource

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

                                                                              Deletes specified tags from a resource.

                                                                              func (*Client) UpdateGatewayRoute

                                                                              func (c *Client) UpdateGatewayRoute(ctx context.Context, params *UpdateGatewayRouteInput, optFns ...func(*Options)) (*UpdateGatewayRouteOutput, error)

                                                                                Updates an existing gateway route that is associated to a specified virtual gateway in a service mesh.

                                                                                func (*Client) UpdateMesh

                                                                                func (c *Client) UpdateMesh(ctx context.Context, params *UpdateMeshInput, optFns ...func(*Options)) (*UpdateMeshOutput, error)

                                                                                  Updates an existing service mesh.

                                                                                  func (*Client) UpdateRoute

                                                                                  func (c *Client) UpdateRoute(ctx context.Context, params *UpdateRouteInput, optFns ...func(*Options)) (*UpdateRouteOutput, error)

                                                                                    Updates an existing route for a specified service mesh and virtual router.

                                                                                    func (*Client) UpdateVirtualGateway

                                                                                    func (c *Client) UpdateVirtualGateway(ctx context.Context, params *UpdateVirtualGatewayInput, optFns ...func(*Options)) (*UpdateVirtualGatewayOutput, error)

                                                                                      Updates an existing virtual gateway in a specified service mesh.

                                                                                      func (*Client) UpdateVirtualNode

                                                                                      func (c *Client) UpdateVirtualNode(ctx context.Context, params *UpdateVirtualNodeInput, optFns ...func(*Options)) (*UpdateVirtualNodeOutput, error)

                                                                                        Updates an existing virtual node in a specified service mesh.

                                                                                        func (*Client) UpdateVirtualRouter

                                                                                        func (c *Client) UpdateVirtualRouter(ctx context.Context, params *UpdateVirtualRouterInput, optFns ...func(*Options)) (*UpdateVirtualRouterOutput, error)

                                                                                          Updates an existing virtual router in a specified service mesh.

                                                                                          func (*Client) UpdateVirtualService

                                                                                          func (c *Client) UpdateVirtualService(ctx context.Context, params *UpdateVirtualServiceInput, optFns ...func(*Options)) (*UpdateVirtualServiceOutput, error)

                                                                                            Updates an existing virtual service in a specified service mesh.

                                                                                            type CreateGatewayRouteInput

                                                                                            type CreateGatewayRouteInput struct {
                                                                                            
                                                                                            	// The name to use for the gateway route.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	GatewayRouteName *string
                                                                                            
                                                                                            	// The name of the service mesh to create the gateway route in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The gateway route specification to apply.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Spec *types.GatewayRouteSpec
                                                                                            
                                                                                            	// The name of the virtual gateway to associate the gateway route with. If the
                                                                                            	// virtual gateway is in a shared mesh, then you must be the owner of the virtual
                                                                                            	// gateway resource.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualGatewayName *string
                                                                                            
                                                                                            	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                            	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                            	ClientToken *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then the account that you specify must share the mesh with your account
                                                                                            	// before you can create the resource in the service mesh. For more information
                                                                                            	// about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            
                                                                                            	// Optional metadata that you can apply to the gateway route to assist with
                                                                                            	// categorization and organization. Each tag consists of a key and an optional
                                                                                            	// value, both of which you define. Tag keys can have a maximum character length of
                                                                                            	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                                                            	Tags []types.TagRef
                                                                                            }

                                                                                            type CreateGatewayRouteOutput

                                                                                            type CreateGatewayRouteOutput struct {
                                                                                            
                                                                                            	// The full description of your gateway route following the create call.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	GatewayRoute *types.GatewayRouteData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type CreateMeshInput

                                                                                            type CreateMeshInput struct {
                                                                                            
                                                                                            	// The name to use for the service mesh.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                            	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                            	ClientToken *string
                                                                                            
                                                                                            	// The service mesh specification to apply.
                                                                                            	Spec *types.MeshSpec
                                                                                            
                                                                                            	// Optional metadata that you can apply to the service mesh to assist with
                                                                                            	// categorization and organization. Each tag consists of a key and an optional
                                                                                            	// value, both of which you define. Tag keys can have a maximum character length of
                                                                                            	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                                                            	Tags []types.TagRef
                                                                                            }

                                                                                            type CreateMeshOutput

                                                                                            type CreateMeshOutput struct {
                                                                                            
                                                                                            	// The full description of your service mesh following the create call.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Mesh *types.MeshData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type CreateRouteInput

                                                                                            type CreateRouteInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to create the route in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name to use for the route.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	RouteName *string
                                                                                            
                                                                                            	// The route specification to apply.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Spec *types.RouteSpec
                                                                                            
                                                                                            	// The name of the virtual router in which to create the route. If the virtual
                                                                                            	// router is in a shared mesh, then you must be the owner of the virtual router
                                                                                            	// resource.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualRouterName *string
                                                                                            
                                                                                            	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                            	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                            	ClientToken *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then the account that you specify must share the mesh with your account
                                                                                            	// before you can create the resource in the service mesh. For more information
                                                                                            	// about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            
                                                                                            	// Optional metadata that you can apply to the route to assist with categorization
                                                                                            	// and organization. Each tag consists of a key and an optional value, both of
                                                                                            	// which you define. Tag keys can have a maximum character length of 128
                                                                                            	// characters, and tag values can have a maximum length of 256 characters.
                                                                                            	Tags []types.TagRef
                                                                                            }

                                                                                            type CreateRouteOutput

                                                                                            type CreateRouteOutput struct {
                                                                                            
                                                                                            	// The full description of your mesh following the create call.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Route *types.RouteData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type CreateVirtualGatewayInput

                                                                                            type CreateVirtualGatewayInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to create the virtual gateway in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The virtual gateway specification to apply.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Spec *types.VirtualGatewaySpec
                                                                                            
                                                                                            	// The name to use for the virtual gateway.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualGatewayName *string
                                                                                            
                                                                                            	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                            	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                            	ClientToken *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then the account that you specify must share the mesh with your account
                                                                                            	// before you can create the resource in the service mesh. For more information
                                                                                            	// about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            
                                                                                            	// Optional metadata that you can apply to the virtual gateway to assist with
                                                                                            	// categorization and organization. Each tag consists of a key and an optional
                                                                                            	// value, both of which you define. Tag keys can have a maximum character length of
                                                                                            	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                                                            	Tags []types.TagRef
                                                                                            }

                                                                                            type CreateVirtualGatewayOutput

                                                                                            type CreateVirtualGatewayOutput struct {
                                                                                            
                                                                                            	// The full description of your virtual gateway following the create call.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualGateway *types.VirtualGatewayData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type CreateVirtualNodeInput

                                                                                            type CreateVirtualNodeInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to create the virtual node in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The virtual node specification to apply.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Spec *types.VirtualNodeSpec
                                                                                            
                                                                                            	// The name to use for the virtual node.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualNodeName *string
                                                                                            
                                                                                            	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                            	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                            	ClientToken *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then the account that you specify must share the mesh with your account
                                                                                            	// before you can create the resource in the service mesh. For more information
                                                                                            	// about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            
                                                                                            	// Optional metadata that you can apply to the virtual node to assist with
                                                                                            	// categorization and organization. Each tag consists of a key and an optional
                                                                                            	// value, both of which you define. Tag keys can have a maximum character length of
                                                                                            	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                                                            	Tags []types.TagRef
                                                                                            }

                                                                                            type CreateVirtualNodeOutput

                                                                                            type CreateVirtualNodeOutput struct {
                                                                                            
                                                                                            	// The full description of your virtual node following the create call.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualNode *types.VirtualNodeData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type CreateVirtualRouterInput

                                                                                            type CreateVirtualRouterInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to create the virtual router in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The virtual router specification to apply.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Spec *types.VirtualRouterSpec
                                                                                            
                                                                                            	// The name to use for the virtual router.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualRouterName *string
                                                                                            
                                                                                            	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                            	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                            	ClientToken *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then the account that you specify must share the mesh with your account
                                                                                            	// before you can create the resource in the service mesh. For more information
                                                                                            	// about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            
                                                                                            	// Optional metadata that you can apply to the virtual router to assist with
                                                                                            	// categorization and organization. Each tag consists of a key and an optional
                                                                                            	// value, both of which you define. Tag keys can have a maximum character length of
                                                                                            	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                                                            	Tags []types.TagRef
                                                                                            }

                                                                                            type CreateVirtualRouterOutput

                                                                                            type CreateVirtualRouterOutput struct {
                                                                                            
                                                                                            	// The full description of your virtual router following the create call.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualRouter *types.VirtualRouterData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type CreateVirtualServiceInput

                                                                                            type CreateVirtualServiceInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to create the virtual service in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The virtual service specification to apply.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Spec *types.VirtualServiceSpec
                                                                                            
                                                                                            	// The name to use for the virtual service.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualServiceName *string
                                                                                            
                                                                                            	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                            	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                            	ClientToken *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then the account that you specify must share the mesh with your account
                                                                                            	// before you can create the resource in the service mesh. For more information
                                                                                            	// about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            
                                                                                            	// Optional metadata that you can apply to the virtual service to assist with
                                                                                            	// categorization and organization. Each tag consists of a key and an optional
                                                                                            	// value, both of which you define. Tag keys can have a maximum character length of
                                                                                            	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                                                            	Tags []types.TagRef
                                                                                            }

                                                                                            type CreateVirtualServiceOutput

                                                                                            type CreateVirtualServiceOutput struct {
                                                                                            
                                                                                            	// The full description of your virtual service following the create call.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualService *types.VirtualServiceData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteGatewayRouteInput

                                                                                            type DeleteGatewayRouteInput struct {
                                                                                            
                                                                                            	// The name of the gateway route to delete.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	GatewayRouteName *string
                                                                                            
                                                                                            	// The name of the service mesh to delete the gateway route from.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the virtual gateway to delete the route from.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualGatewayName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DeleteGatewayRouteOutput

                                                                                            type DeleteGatewayRouteOutput struct {
                                                                                            
                                                                                            	// The gateway route that was deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	GatewayRoute *types.GatewayRouteData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteMeshInput

                                                                                            type DeleteMeshInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to delete.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            }

                                                                                            type DeleteMeshOutput

                                                                                            type DeleteMeshOutput struct {
                                                                                            
                                                                                            	// The service mesh that was deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Mesh *types.MeshData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteRouteInput

                                                                                            type DeleteRouteInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to delete the route in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the route to delete.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	RouteName *string
                                                                                            
                                                                                            	// The name of the virtual router to delete the route in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualRouterName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DeleteRouteOutput

                                                                                            type DeleteRouteOutput struct {
                                                                                            
                                                                                            	// The route that was deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Route *types.RouteData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteVirtualGatewayInput

                                                                                            type DeleteVirtualGatewayInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to delete the virtual gateway from.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the virtual gateway to delete.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualGatewayName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DeleteVirtualGatewayOutput

                                                                                            type DeleteVirtualGatewayOutput struct {
                                                                                            
                                                                                            	// The virtual gateway that was deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualGateway *types.VirtualGatewayData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteVirtualNodeInput

                                                                                            type DeleteVirtualNodeInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to delete the virtual node in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the virtual node to delete.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualNodeName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DeleteVirtualNodeOutput

                                                                                            type DeleteVirtualNodeOutput struct {
                                                                                            
                                                                                            	// The virtual node that was deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualNode *types.VirtualNodeData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteVirtualRouterInput

                                                                                            type DeleteVirtualRouterInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to delete the virtual router in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the virtual router to delete.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualRouterName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DeleteVirtualRouterOutput

                                                                                            type DeleteVirtualRouterOutput struct {
                                                                                            
                                                                                            	// The virtual router that was deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualRouter *types.VirtualRouterData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteVirtualServiceInput

                                                                                            type DeleteVirtualServiceInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to delete the virtual service in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the virtual service to delete.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualServiceName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DeleteVirtualServiceOutput

                                                                                            type DeleteVirtualServiceOutput struct {
                                                                                            
                                                                                            	// The virtual service that was deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualService *types.VirtualServiceData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeGatewayRouteInput

                                                                                            type DescribeGatewayRouteInput struct {
                                                                                            
                                                                                            	// The name of the gateway route to describe.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	GatewayRouteName *string
                                                                                            
                                                                                            	// The name of the service mesh that the gateway route resides in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the virtual gateway that the gateway route is associated with.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualGatewayName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DescribeGatewayRouteOutput

                                                                                            type DescribeGatewayRouteOutput struct {
                                                                                            
                                                                                            	// The full description of your gateway route.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	GatewayRoute *types.GatewayRouteData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeMeshInput

                                                                                            type DescribeMeshInput struct {
                                                                                            
                                                                                            	// The name of the service mesh to describe.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DescribeMeshOutput

                                                                                            type DescribeMeshOutput struct {
                                                                                            
                                                                                            	// The full description of your service mesh.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Mesh *types.MeshData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeRouteInput

                                                                                            type DescribeRouteInput struct {
                                                                                            
                                                                                            	// The name of the service mesh that the route resides in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the route to describe.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	RouteName *string
                                                                                            
                                                                                            	// The name of the virtual router that the route is associated with.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualRouterName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DescribeRouteOutput

                                                                                            type DescribeRouteOutput struct {
                                                                                            
                                                                                            	// The full description of your route.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Route *types.RouteData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeVirtualGatewayInput

                                                                                            type DescribeVirtualGatewayInput struct {
                                                                                            
                                                                                            	// The name of the service mesh that the gateway route resides in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the virtual gateway to describe.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualGatewayName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DescribeVirtualGatewayOutput

                                                                                            type DescribeVirtualGatewayOutput struct {
                                                                                            
                                                                                            	// The full description of your virtual gateway.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualGateway *types.VirtualGatewayData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeVirtualNodeInput

                                                                                            type DescribeVirtualNodeInput struct {
                                                                                            
                                                                                            	// The name of the service mesh that the virtual node resides in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the virtual node to describe.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualNodeName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DescribeVirtualNodeOutput

                                                                                            type DescribeVirtualNodeOutput struct {
                                                                                            
                                                                                            	// The full description of your virtual node.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualNode *types.VirtualNodeData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeVirtualRouterInput

                                                                                            type DescribeVirtualRouterInput struct {
                                                                                            
                                                                                            	// The name of the service mesh that the virtual router resides in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the virtual router to describe.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualRouterName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DescribeVirtualRouterOutput

                                                                                            type DescribeVirtualRouterOutput struct {
                                                                                            
                                                                                            	// The full description of your virtual router.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualRouter *types.VirtualRouterData
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeVirtualServiceInput

                                                                                            type DescribeVirtualServiceInput struct {
                                                                                            
                                                                                            	// The name of the service mesh that the virtual service resides in.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	MeshName *string
                                                                                            
                                                                                            	// The name of the virtual service to describe.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualServiceName *string
                                                                                            
                                                                                            	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                            	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                            	// more information about mesh sharing, see Working with shared meshes
                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                            	MeshOwner *string
                                                                                            }

                                                                                            type DescribeVirtualServiceOutput

                                                                                            type DescribeVirtualServiceOutput struct {
                                                                                            
                                                                                            	// The full description of your virtual service.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	VirtualService *types.VirtualServiceData
                                                                                            
                                                                                            	// 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 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 ListGatewayRoutesAPIClient

                                                                                                    type ListGatewayRoutesAPIClient interface {
                                                                                                    	ListGatewayRoutes(context.Context, *ListGatewayRoutesInput, ...func(*Options)) (*ListGatewayRoutesOutput, error)
                                                                                                    }

                                                                                                      ListGatewayRoutesAPIClient is a client that implements the ListGatewayRoutes operation.

                                                                                                      type ListGatewayRoutesInput

                                                                                                      type ListGatewayRoutesInput struct {
                                                                                                      
                                                                                                      	// The name of the service mesh to list gateway routes in.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	MeshName *string
                                                                                                      
                                                                                                      	// The name of the virtual gateway to list gateway routes in.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	VirtualGatewayName *string
                                                                                                      
                                                                                                      	// The maximum number of results returned by ListGatewayRoutes in paginated output.
                                                                                                      	// When you use this parameter, ListGatewayRoutes returns only limit results in a
                                                                                                      	// single page along with a nextToken response element. You can see the remaining
                                                                                                      	// results of the initial request by sending another ListGatewayRoutes request with
                                                                                                      	// the returned nextToken value. This value can be between 1 and 100. If you don't
                                                                                                      	// use this parameter, ListGatewayRoutes returns up to 100 results and a nextToken
                                                                                                      	// value if applicable.
                                                                                                      	Limit *int32
                                                                                                      
                                                                                                      	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                      	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                      	// more information about mesh sharing, see Working with shared meshes
                                                                                                      	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                      	MeshOwner *string
                                                                                                      
                                                                                                      	// The nextToken value returned from a previous paginated ListGatewayRoutes request
                                                                                                      	// where limit was used and the results exceeded the value of that parameter.
                                                                                                      	// Pagination continues from the end of the previous results that returned the
                                                                                                      	// nextToken value.
                                                                                                      	NextToken *string
                                                                                                      }

                                                                                                      type ListGatewayRoutesOutput

                                                                                                      type ListGatewayRoutesOutput struct {
                                                                                                      
                                                                                                      	// The list of existing gateway routes for the specified service mesh and virtual
                                                                                                      	// gateway.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	GatewayRoutes []types.GatewayRouteRef
                                                                                                      
                                                                                                      	// The nextToken value to include in a future ListGatewayRoutes request. When the
                                                                                                      	// results of a ListGatewayRoutes request exceed limit, you can use this value to
                                                                                                      	// retrieve the next page of results. This value is null when there are no more
                                                                                                      	// results to return.
                                                                                                      	NextToken *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type ListGatewayRoutesPaginator

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

                                                                                                        ListGatewayRoutesPaginator is a paginator for ListGatewayRoutes

                                                                                                        func NewListGatewayRoutesPaginator

                                                                                                        func NewListGatewayRoutesPaginator(client ListGatewayRoutesAPIClient, params *ListGatewayRoutesInput, optFns ...func(*ListGatewayRoutesPaginatorOptions)) *ListGatewayRoutesPaginator

                                                                                                          NewListGatewayRoutesPaginator returns a new ListGatewayRoutesPaginator

                                                                                                          func (*ListGatewayRoutesPaginator) HasMorePages

                                                                                                          func (p *ListGatewayRoutesPaginator) HasMorePages() bool

                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                            func (*ListGatewayRoutesPaginator) NextPage

                                                                                                            func (p *ListGatewayRoutesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListGatewayRoutesOutput, error)

                                                                                                              NextPage retrieves the next ListGatewayRoutes page.

                                                                                                              type ListGatewayRoutesPaginatorOptions

                                                                                                              type ListGatewayRoutesPaginatorOptions struct {
                                                                                                              	// The maximum number of results returned by ListGatewayRoutes in paginated output.
                                                                                                              	// When you use this parameter, ListGatewayRoutes returns only limit results in a
                                                                                                              	// single page along with a nextToken response element. You can see the remaining
                                                                                                              	// results of the initial request by sending another ListGatewayRoutes request with
                                                                                                              	// the returned nextToken value. This value can be between 1 and 100. If you don't
                                                                                                              	// use this parameter, ListGatewayRoutes returns up to 100 results and a nextToken
                                                                                                              	// value if applicable.
                                                                                                              	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
                                                                                                              }

                                                                                                                ListGatewayRoutesPaginatorOptions is the paginator options for ListGatewayRoutes

                                                                                                                type ListMeshesAPIClient

                                                                                                                type ListMeshesAPIClient interface {
                                                                                                                	ListMeshes(context.Context, *ListMeshesInput, ...func(*Options)) (*ListMeshesOutput, error)
                                                                                                                }

                                                                                                                  ListMeshesAPIClient is a client that implements the ListMeshes operation.

                                                                                                                  type ListMeshesInput

                                                                                                                  type ListMeshesInput struct {
                                                                                                                  
                                                                                                                  	// The maximum number of results returned by ListMeshes in paginated output. When
                                                                                                                  	// you use this parameter, ListMeshes returns only limit results in a single page
                                                                                                                  	// along with a nextToken response element. You can see the remaining results of
                                                                                                                  	// the initial request by sending another ListMeshes request with the returned
                                                                                                                  	// nextToken value. This value can be between 1 and 100. If you don't use this
                                                                                                                  	// parameter, ListMeshes returns up to 100 results and a nextToken value if
                                                                                                                  	// applicable.
                                                                                                                  	Limit *int32
                                                                                                                  
                                                                                                                  	// The nextToken value returned from a previous paginated ListMeshes request where
                                                                                                                  	// limit was used and the results exceeded the value of that parameter. Pagination
                                                                                                                  	// continues from the end of the previous results that returned the nextToken
                                                                                                                  	// value. This token should be treated as an opaque identifier that is used only to
                                                                                                                  	// retrieve the next items in a list and not for other programmatic purposes.
                                                                                                                  	NextToken *string
                                                                                                                  }

                                                                                                                  type ListMeshesOutput

                                                                                                                  type ListMeshesOutput struct {
                                                                                                                  
                                                                                                                  	// The list of existing service meshes.
                                                                                                                  	//
                                                                                                                  	// This member is required.
                                                                                                                  	Meshes []types.MeshRef
                                                                                                                  
                                                                                                                  	// The nextToken value to include in a future ListMeshes request. When the results
                                                                                                                  	// of a ListMeshes request exceed limit, you can use this value to retrieve the
                                                                                                                  	// next page of results. This value is null when there are no more results to
                                                                                                                  	// return.
                                                                                                                  	NextToken *string
                                                                                                                  
                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                  }

                                                                                                                  type ListMeshesPaginator

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

                                                                                                                    ListMeshesPaginator is a paginator for ListMeshes

                                                                                                                    func NewListMeshesPaginator

                                                                                                                    func NewListMeshesPaginator(client ListMeshesAPIClient, params *ListMeshesInput, optFns ...func(*ListMeshesPaginatorOptions)) *ListMeshesPaginator

                                                                                                                      NewListMeshesPaginator returns a new ListMeshesPaginator

                                                                                                                      func (*ListMeshesPaginator) HasMorePages

                                                                                                                      func (p *ListMeshesPaginator) HasMorePages() bool

                                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                        func (*ListMeshesPaginator) NextPage

                                                                                                                        func (p *ListMeshesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListMeshesOutput, error)

                                                                                                                          NextPage retrieves the next ListMeshes page.

                                                                                                                          type ListMeshesPaginatorOptions

                                                                                                                          type ListMeshesPaginatorOptions struct {
                                                                                                                          	// The maximum number of results returned by ListMeshes in paginated output. When
                                                                                                                          	// you use this parameter, ListMeshes returns only limit results in a single page
                                                                                                                          	// along with a nextToken response element. You can see the remaining results of
                                                                                                                          	// the initial request by sending another ListMeshes request with the returned
                                                                                                                          	// nextToken value. This value can be between 1 and 100. If you don't use this
                                                                                                                          	// parameter, ListMeshes returns up to 100 results and a nextToken value if
                                                                                                                          	// applicable.
                                                                                                                          	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
                                                                                                                          }

                                                                                                                            ListMeshesPaginatorOptions is the paginator options for ListMeshes

                                                                                                                            type ListRoutesAPIClient

                                                                                                                            type ListRoutesAPIClient interface {
                                                                                                                            	ListRoutes(context.Context, *ListRoutesInput, ...func(*Options)) (*ListRoutesOutput, error)
                                                                                                                            }

                                                                                                                              ListRoutesAPIClient is a client that implements the ListRoutes operation.

                                                                                                                              type ListRoutesInput

                                                                                                                              type ListRoutesInput struct {
                                                                                                                              
                                                                                                                              	// The name of the service mesh to list routes in.
                                                                                                                              	//
                                                                                                                              	// This member is required.
                                                                                                                              	MeshName *string
                                                                                                                              
                                                                                                                              	// The name of the virtual router to list routes in.
                                                                                                                              	//
                                                                                                                              	// This member is required.
                                                                                                                              	VirtualRouterName *string
                                                                                                                              
                                                                                                                              	// The maximum number of results returned by ListRoutes in paginated output. When
                                                                                                                              	// you use this parameter, ListRoutes returns only limit results in a single page
                                                                                                                              	// along with a nextToken response element. You can see the remaining results of
                                                                                                                              	// the initial request by sending another ListRoutes request with the returned
                                                                                                                              	// nextToken value. This value can be between 1 and 100. If you don't use this
                                                                                                                              	// parameter, ListRoutes returns up to 100 results and a nextToken value if
                                                                                                                              	// applicable.
                                                                                                                              	Limit *int32
                                                                                                                              
                                                                                                                              	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                                              	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                                              	// more information about mesh sharing, see Working with shared meshes
                                                                                                                              	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                              	MeshOwner *string
                                                                                                                              
                                                                                                                              	// The nextToken value returned from a previous paginated ListRoutes request where
                                                                                                                              	// limit was used and the results exceeded the value of that parameter. Pagination
                                                                                                                              	// continues from the end of the previous results that returned the nextToken
                                                                                                                              	// value.
                                                                                                                              	NextToken *string
                                                                                                                              }

                                                                                                                              type ListRoutesOutput

                                                                                                                              type ListRoutesOutput struct {
                                                                                                                              
                                                                                                                              	// The list of existing routes for the specified service mesh and virtual router.
                                                                                                                              	//
                                                                                                                              	// This member is required.
                                                                                                                              	Routes []types.RouteRef
                                                                                                                              
                                                                                                                              	// The nextToken value to include in a future ListRoutes request. When the results
                                                                                                                              	// of a ListRoutes request exceed limit, you can use this value to retrieve the
                                                                                                                              	// next page of results. This value is null when there are no more results to
                                                                                                                              	// return.
                                                                                                                              	NextToken *string
                                                                                                                              
                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                              }

                                                                                                                              type ListRoutesPaginator

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

                                                                                                                                ListRoutesPaginator is a paginator for ListRoutes

                                                                                                                                func NewListRoutesPaginator

                                                                                                                                func NewListRoutesPaginator(client ListRoutesAPIClient, params *ListRoutesInput, optFns ...func(*ListRoutesPaginatorOptions)) *ListRoutesPaginator

                                                                                                                                  NewListRoutesPaginator returns a new ListRoutesPaginator

                                                                                                                                  func (*ListRoutesPaginator) HasMorePages

                                                                                                                                  func (p *ListRoutesPaginator) HasMorePages() bool

                                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                    func (*ListRoutesPaginator) NextPage

                                                                                                                                    func (p *ListRoutesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListRoutesOutput, error)

                                                                                                                                      NextPage retrieves the next ListRoutes page.

                                                                                                                                      type ListRoutesPaginatorOptions

                                                                                                                                      type ListRoutesPaginatorOptions struct {
                                                                                                                                      	// The maximum number of results returned by ListRoutes in paginated output. When
                                                                                                                                      	// you use this parameter, ListRoutes returns only limit results in a single page
                                                                                                                                      	// along with a nextToken response element. You can see the remaining results of
                                                                                                                                      	// the initial request by sending another ListRoutes request with the returned
                                                                                                                                      	// nextToken value. This value can be between 1 and 100. If you don't use this
                                                                                                                                      	// parameter, ListRoutes returns up to 100 results and a nextToken value if
                                                                                                                                      	// applicable.
                                                                                                                                      	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
                                                                                                                                      }

                                                                                                                                        ListRoutesPaginatorOptions is the paginator options for ListRoutes

                                                                                                                                        type ListTagsForResourceAPIClient

                                                                                                                                        type ListTagsForResourceAPIClient interface {
                                                                                                                                        	ListTagsForResource(context.Context, *ListTagsForResourceInput, ...func(*Options)) (*ListTagsForResourceOutput, error)
                                                                                                                                        }

                                                                                                                                          ListTagsForResourceAPIClient is a client that implements the ListTagsForResource operation.

                                                                                                                                          type ListTagsForResourceInput

                                                                                                                                          type ListTagsForResourceInput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) that identifies the resource to list the tags
                                                                                                                                          	// for.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	ResourceArn *string
                                                                                                                                          
                                                                                                                                          	// The maximum number of tag results returned by ListTagsForResource in paginated
                                                                                                                                          	// output. When this parameter is used, ListTagsForResource returns only limit
                                                                                                                                          	// results in a single page along with a nextToken response element. You can see
                                                                                                                                          	// the remaining results of the initial request by sending another
                                                                                                                                          	// ListTagsForResource request with the returned nextToken value. This value can be
                                                                                                                                          	// between 1 and 100. If you don't use this parameter, ListTagsForResource returns
                                                                                                                                          	// up to 100 results and a nextToken value if applicable.
                                                                                                                                          	Limit *int32
                                                                                                                                          
                                                                                                                                          	// The nextToken value returned from a previous paginated ListTagsForResource
                                                                                                                                          	// request where limit was used and the results exceeded the value of that
                                                                                                                                          	// parameter. Pagination continues from the end of the previous results that
                                                                                                                                          	// returned the nextToken value.
                                                                                                                                          	NextToken *string
                                                                                                                                          }

                                                                                                                                          type ListTagsForResourceOutput

                                                                                                                                          type ListTagsForResourceOutput struct {
                                                                                                                                          
                                                                                                                                          	// The tags for the resource.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Tags []types.TagRef
                                                                                                                                          
                                                                                                                                          	// The nextToken value to include in a future ListTagsForResource request. When the
                                                                                                                                          	// results of a ListTagsForResource request exceed limit, you can use this value to
                                                                                                                                          	// retrieve the next page of results. This value is null when there are no more
                                                                                                                                          	// results to return.
                                                                                                                                          	NextToken *string
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type ListTagsForResourcePaginator

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

                                                                                                                                            ListTagsForResourcePaginator is a paginator for ListTagsForResource

                                                                                                                                            func NewListTagsForResourcePaginator

                                                                                                                                            func NewListTagsForResourcePaginator(client ListTagsForResourceAPIClient, params *ListTagsForResourceInput, optFns ...func(*ListTagsForResourcePaginatorOptions)) *ListTagsForResourcePaginator

                                                                                                                                              NewListTagsForResourcePaginator returns a new ListTagsForResourcePaginator

                                                                                                                                              func (*ListTagsForResourcePaginator) HasMorePages

                                                                                                                                              func (p *ListTagsForResourcePaginator) HasMorePages() bool

                                                                                                                                                HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                func (*ListTagsForResourcePaginator) NextPage

                                                                                                                                                func (p *ListTagsForResourcePaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                                                                                                                  NextPage retrieves the next ListTagsForResource page.

                                                                                                                                                  type ListTagsForResourcePaginatorOptions

                                                                                                                                                  type ListTagsForResourcePaginatorOptions struct {
                                                                                                                                                  	// The maximum number of tag results returned by ListTagsForResource in paginated
                                                                                                                                                  	// output. When this parameter is used, ListTagsForResource returns only limit
                                                                                                                                                  	// results in a single page along with a nextToken response element. You can see
                                                                                                                                                  	// the remaining results of the initial request by sending another
                                                                                                                                                  	// ListTagsForResource request with the returned nextToken value. This value can be
                                                                                                                                                  	// between 1 and 100. If you don't use this parameter, ListTagsForResource returns
                                                                                                                                                  	// up to 100 results and a nextToken value if applicable.
                                                                                                                                                  	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
                                                                                                                                                  }

                                                                                                                                                    ListTagsForResourcePaginatorOptions is the paginator options for ListTagsForResource

                                                                                                                                                    type ListVirtualGatewaysAPIClient

                                                                                                                                                    type ListVirtualGatewaysAPIClient interface {
                                                                                                                                                    	ListVirtualGateways(context.Context, *ListVirtualGatewaysInput, ...func(*Options)) (*ListVirtualGatewaysOutput, error)
                                                                                                                                                    }

                                                                                                                                                      ListVirtualGatewaysAPIClient is a client that implements the ListVirtualGateways operation.

                                                                                                                                                      type ListVirtualGatewaysInput

                                                                                                                                                      type ListVirtualGatewaysInput struct {
                                                                                                                                                      
                                                                                                                                                      	// The name of the service mesh to list virtual gateways in.
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	MeshName *string
                                                                                                                                                      
                                                                                                                                                      	// The maximum number of results returned by ListVirtualGateways in paginated
                                                                                                                                                      	// output. When you use this parameter, ListVirtualGateways returns only limit
                                                                                                                                                      	// results in a single page along with a nextToken response element. You can see
                                                                                                                                                      	// the remaining results of the initial request by sending another
                                                                                                                                                      	// ListVirtualGateways request with the returned nextToken value. This value can be
                                                                                                                                                      	// between 1 and 100. If you don't use this parameter, ListVirtualGateways returns
                                                                                                                                                      	// up to 100 results and a nextToken value if applicable.
                                                                                                                                                      	Limit *int32
                                                                                                                                                      
                                                                                                                                                      	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                                                                      	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                                                                      	// more information about mesh sharing, see Working with shared meshes
                                                                                                                                                      	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                      	MeshOwner *string
                                                                                                                                                      
                                                                                                                                                      	// The nextToken value returned from a previous paginated ListVirtualGateways
                                                                                                                                                      	// request where limit was used and the results exceeded the value of that
                                                                                                                                                      	// parameter. Pagination continues from the end of the previous results that
                                                                                                                                                      	// returned the nextToken value.
                                                                                                                                                      	NextToken *string
                                                                                                                                                      }

                                                                                                                                                      type ListVirtualGatewaysOutput

                                                                                                                                                      type ListVirtualGatewaysOutput struct {
                                                                                                                                                      
                                                                                                                                                      	// The list of existing virtual gateways for the specified service mesh.
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	VirtualGateways []types.VirtualGatewayRef
                                                                                                                                                      
                                                                                                                                                      	// The nextToken value to include in a future ListVirtualGateways request. When the
                                                                                                                                                      	// results of a ListVirtualGateways request exceed limit, you can use this value to
                                                                                                                                                      	// retrieve the next page of results. This value is null when there are no more
                                                                                                                                                      	// results to return.
                                                                                                                                                      	NextToken *string
                                                                                                                                                      
                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                      }

                                                                                                                                                      type ListVirtualGatewaysPaginator

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

                                                                                                                                                        ListVirtualGatewaysPaginator is a paginator for ListVirtualGateways

                                                                                                                                                        func NewListVirtualGatewaysPaginator

                                                                                                                                                        func NewListVirtualGatewaysPaginator(client ListVirtualGatewaysAPIClient, params *ListVirtualGatewaysInput, optFns ...func(*ListVirtualGatewaysPaginatorOptions)) *ListVirtualGatewaysPaginator

                                                                                                                                                          NewListVirtualGatewaysPaginator returns a new ListVirtualGatewaysPaginator

                                                                                                                                                          func (*ListVirtualGatewaysPaginator) HasMorePages

                                                                                                                                                          func (p *ListVirtualGatewaysPaginator) HasMorePages() bool

                                                                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                            func (*ListVirtualGatewaysPaginator) NextPage

                                                                                                                                                            func (p *ListVirtualGatewaysPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListVirtualGatewaysOutput, error)

                                                                                                                                                              NextPage retrieves the next ListVirtualGateways page.

                                                                                                                                                              type ListVirtualGatewaysPaginatorOptions

                                                                                                                                                              type ListVirtualGatewaysPaginatorOptions struct {
                                                                                                                                                              	// The maximum number of results returned by ListVirtualGateways in paginated
                                                                                                                                                              	// output. When you use this parameter, ListVirtualGateways returns only limit
                                                                                                                                                              	// results in a single page along with a nextToken response element. You can see
                                                                                                                                                              	// the remaining results of the initial request by sending another
                                                                                                                                                              	// ListVirtualGateways request with the returned nextToken value. This value can be
                                                                                                                                                              	// between 1 and 100. If you don't use this parameter, ListVirtualGateways returns
                                                                                                                                                              	// up to 100 results and a nextToken value if applicable.
                                                                                                                                                              	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
                                                                                                                                                              }

                                                                                                                                                                ListVirtualGatewaysPaginatorOptions is the paginator options for ListVirtualGateways

                                                                                                                                                                type ListVirtualNodesAPIClient

                                                                                                                                                                type ListVirtualNodesAPIClient interface {
                                                                                                                                                                	ListVirtualNodes(context.Context, *ListVirtualNodesInput, ...func(*Options)) (*ListVirtualNodesOutput, error)
                                                                                                                                                                }

                                                                                                                                                                  ListVirtualNodesAPIClient is a client that implements the ListVirtualNodes operation.

                                                                                                                                                                  type ListVirtualNodesInput

                                                                                                                                                                  type ListVirtualNodesInput struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The name of the service mesh to list virtual nodes in.
                                                                                                                                                                  	//
                                                                                                                                                                  	// This member is required.
                                                                                                                                                                  	MeshName *string
                                                                                                                                                                  
                                                                                                                                                                  	// The maximum number of results returned by ListVirtualNodes in paginated output.
                                                                                                                                                                  	// When you use this parameter, ListVirtualNodes returns only limit results in a
                                                                                                                                                                  	// single page along with a nextToken response element. You can see the remaining
                                                                                                                                                                  	// results of the initial request by sending another ListVirtualNodes request with
                                                                                                                                                                  	// the returned nextToken value. This value can be between 1 and 100. If you don't
                                                                                                                                                                  	// use this parameter, ListVirtualNodes returns up to 100 results and a nextToken
                                                                                                                                                                  	// value if applicable.
                                                                                                                                                                  	Limit *int32
                                                                                                                                                                  
                                                                                                                                                                  	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                                                                                  	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                                                                                  	// more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                  	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                  	MeshOwner *string
                                                                                                                                                                  
                                                                                                                                                                  	// The nextToken value returned from a previous paginated ListVirtualNodes request
                                                                                                                                                                  	// where limit was used and the results exceeded the value of that parameter.
                                                                                                                                                                  	// Pagination continues from the end of the previous results that returned the
                                                                                                                                                                  	// nextToken value.
                                                                                                                                                                  	NextToken *string
                                                                                                                                                                  }

                                                                                                                                                                  type ListVirtualNodesOutput

                                                                                                                                                                  type ListVirtualNodesOutput struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The list of existing virtual nodes for the specified service mesh.
                                                                                                                                                                  	//
                                                                                                                                                                  	// This member is required.
                                                                                                                                                                  	VirtualNodes []types.VirtualNodeRef
                                                                                                                                                                  
                                                                                                                                                                  	// The nextToken value to include in a future ListVirtualNodes request. When the
                                                                                                                                                                  	// results of a ListVirtualNodes request exceed limit, you can use this value to
                                                                                                                                                                  	// retrieve the next page of results. This value is null when there are no more
                                                                                                                                                                  	// results to return.
                                                                                                                                                                  	NextToken *string
                                                                                                                                                                  
                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                  }

                                                                                                                                                                  type ListVirtualNodesPaginator

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

                                                                                                                                                                    ListVirtualNodesPaginator is a paginator for ListVirtualNodes

                                                                                                                                                                    func NewListVirtualNodesPaginator

                                                                                                                                                                    func NewListVirtualNodesPaginator(client ListVirtualNodesAPIClient, params *ListVirtualNodesInput, optFns ...func(*ListVirtualNodesPaginatorOptions)) *ListVirtualNodesPaginator

                                                                                                                                                                      NewListVirtualNodesPaginator returns a new ListVirtualNodesPaginator

                                                                                                                                                                      func (*ListVirtualNodesPaginator) HasMorePages

                                                                                                                                                                      func (p *ListVirtualNodesPaginator) HasMorePages() bool

                                                                                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                        func (*ListVirtualNodesPaginator) NextPage

                                                                                                                                                                        func (p *ListVirtualNodesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListVirtualNodesOutput, error)

                                                                                                                                                                          NextPage retrieves the next ListVirtualNodes page.

                                                                                                                                                                          type ListVirtualNodesPaginatorOptions

                                                                                                                                                                          type ListVirtualNodesPaginatorOptions struct {
                                                                                                                                                                          	// The maximum number of results returned by ListVirtualNodes in paginated output.
                                                                                                                                                                          	// When you use this parameter, ListVirtualNodes returns only limit results in a
                                                                                                                                                                          	// single page along with a nextToken response element. You can see the remaining
                                                                                                                                                                          	// results of the initial request by sending another ListVirtualNodes request with
                                                                                                                                                                          	// the returned nextToken value. This value can be between 1 and 100. If you don't
                                                                                                                                                                          	// use this parameter, ListVirtualNodes returns up to 100 results and a nextToken
                                                                                                                                                                          	// value if applicable.
                                                                                                                                                                          	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
                                                                                                                                                                          }

                                                                                                                                                                            ListVirtualNodesPaginatorOptions is the paginator options for ListVirtualNodes

                                                                                                                                                                            type ListVirtualRoutersAPIClient

                                                                                                                                                                            type ListVirtualRoutersAPIClient interface {
                                                                                                                                                                            	ListVirtualRouters(context.Context, *ListVirtualRoutersInput, ...func(*Options)) (*ListVirtualRoutersOutput, error)
                                                                                                                                                                            }

                                                                                                                                                                              ListVirtualRoutersAPIClient is a client that implements the ListVirtualRouters operation.

                                                                                                                                                                              type ListVirtualRoutersInput

                                                                                                                                                                              type ListVirtualRoutersInput struct {
                                                                                                                                                                              
                                                                                                                                                                              	// The name of the service mesh to list virtual routers in.
                                                                                                                                                                              	//
                                                                                                                                                                              	// This member is required.
                                                                                                                                                                              	MeshName *string
                                                                                                                                                                              
                                                                                                                                                                              	// The maximum number of results returned by ListVirtualRouters in paginated
                                                                                                                                                                              	// output. When you use this parameter, ListVirtualRouters returns only limit
                                                                                                                                                                              	// results in a single page along with a nextToken response element. You can see
                                                                                                                                                                              	// the remaining results of the initial request by sending another
                                                                                                                                                                              	// ListVirtualRouters request with the returned nextToken value. This value can be
                                                                                                                                                                              	// between 1 and 100. If you don't use this parameter, ListVirtualRouters returns
                                                                                                                                                                              	// up to 100 results and a nextToken value if applicable.
                                                                                                                                                                              	Limit *int32
                                                                                                                                                                              
                                                                                                                                                                              	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                                                                                              	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                                                                                              	// more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                              	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                              	MeshOwner *string
                                                                                                                                                                              
                                                                                                                                                                              	// The nextToken value returned from a previous paginated ListVirtualRouters
                                                                                                                                                                              	// request where limit was used and the results exceeded the value of that
                                                                                                                                                                              	// parameter. Pagination continues from the end of the previous results that
                                                                                                                                                                              	// returned the nextToken value.
                                                                                                                                                                              	NextToken *string
                                                                                                                                                                              }

                                                                                                                                                                              type ListVirtualRoutersOutput

                                                                                                                                                                              type ListVirtualRoutersOutput struct {
                                                                                                                                                                              
                                                                                                                                                                              	// The list of existing virtual routers for the specified service mesh.
                                                                                                                                                                              	//
                                                                                                                                                                              	// This member is required.
                                                                                                                                                                              	VirtualRouters []types.VirtualRouterRef
                                                                                                                                                                              
                                                                                                                                                                              	// The nextToken value to include in a future ListVirtualRouters request. When the
                                                                                                                                                                              	// results of a ListVirtualRouters request exceed limit, you can use this value to
                                                                                                                                                                              	// retrieve the next page of results. This value is null when there are no more
                                                                                                                                                                              	// results to return.
                                                                                                                                                                              	NextToken *string
                                                                                                                                                                              
                                                                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                                                                              }

                                                                                                                                                                              type ListVirtualRoutersPaginator

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

                                                                                                                                                                                ListVirtualRoutersPaginator is a paginator for ListVirtualRouters

                                                                                                                                                                                func NewListVirtualRoutersPaginator

                                                                                                                                                                                func NewListVirtualRoutersPaginator(client ListVirtualRoutersAPIClient, params *ListVirtualRoutersInput, optFns ...func(*ListVirtualRoutersPaginatorOptions)) *ListVirtualRoutersPaginator

                                                                                                                                                                                  NewListVirtualRoutersPaginator returns a new ListVirtualRoutersPaginator

                                                                                                                                                                                  func (*ListVirtualRoutersPaginator) HasMorePages

                                                                                                                                                                                  func (p *ListVirtualRoutersPaginator) HasMorePages() bool

                                                                                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                    func (*ListVirtualRoutersPaginator) NextPage

                                                                                                                                                                                    func (p *ListVirtualRoutersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListVirtualRoutersOutput, error)

                                                                                                                                                                                      NextPage retrieves the next ListVirtualRouters page.

                                                                                                                                                                                      type ListVirtualRoutersPaginatorOptions

                                                                                                                                                                                      type ListVirtualRoutersPaginatorOptions struct {
                                                                                                                                                                                      	// The maximum number of results returned by ListVirtualRouters in paginated
                                                                                                                                                                                      	// output. When you use this parameter, ListVirtualRouters returns only limit
                                                                                                                                                                                      	// results in a single page along with a nextToken response element. You can see
                                                                                                                                                                                      	// the remaining results of the initial request by sending another
                                                                                                                                                                                      	// ListVirtualRouters request with the returned nextToken value. This value can be
                                                                                                                                                                                      	// between 1 and 100. If you don't use this parameter, ListVirtualRouters returns
                                                                                                                                                                                      	// up to 100 results and a nextToken value if applicable.
                                                                                                                                                                                      	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
                                                                                                                                                                                      }

                                                                                                                                                                                        ListVirtualRoutersPaginatorOptions is the paginator options for ListVirtualRouters

                                                                                                                                                                                        type ListVirtualServicesAPIClient

                                                                                                                                                                                        type ListVirtualServicesAPIClient interface {
                                                                                                                                                                                        	ListVirtualServices(context.Context, *ListVirtualServicesInput, ...func(*Options)) (*ListVirtualServicesOutput, error)
                                                                                                                                                                                        }

                                                                                                                                                                                          ListVirtualServicesAPIClient is a client that implements the ListVirtualServices operation.

                                                                                                                                                                                          type ListVirtualServicesInput

                                                                                                                                                                                          type ListVirtualServicesInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the service mesh to list virtual services in.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	MeshName *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The maximum number of results returned by ListVirtualServices in paginated
                                                                                                                                                                                          	// output. When you use this parameter, ListVirtualServices returns only limit
                                                                                                                                                                                          	// results in a single page along with a nextToken response element. You can see
                                                                                                                                                                                          	// the remaining results of the initial request by sending another
                                                                                                                                                                                          	// ListVirtualServices request with the returned nextToken value. This value can be
                                                                                                                                                                                          	// between 1 and 100. If you don't use this parameter, ListVirtualServices returns
                                                                                                                                                                                          	// up to 100 results and a nextToken value if applicable.
                                                                                                                                                                                          	Limit *int32
                                                                                                                                                                                          
                                                                                                                                                                                          	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                                                                                                          	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                                                                                                          	// more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                          	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                          	MeshOwner *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The nextToken value returned from a previous paginated ListVirtualServices
                                                                                                                                                                                          	// request where limit was used and the results exceeded the value of that
                                                                                                                                                                                          	// parameter. Pagination continues from the end of the previous results that
                                                                                                                                                                                          	// returned the nextToken value.
                                                                                                                                                                                          	NextToken *string
                                                                                                                                                                                          }

                                                                                                                                                                                          type ListVirtualServicesOutput

                                                                                                                                                                                          type ListVirtualServicesOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The list of existing virtual services for the specified service mesh.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	VirtualServices []types.VirtualServiceRef
                                                                                                                                                                                          
                                                                                                                                                                                          	// The nextToken value to include in a future ListVirtualServices request. When the
                                                                                                                                                                                          	// results of a ListVirtualServices request exceed limit, you can use this value to
                                                                                                                                                                                          	// retrieve the next page of results. This value is null when there are no more
                                                                                                                                                                                          	// results to return.
                                                                                                                                                                                          	NextToken *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type ListVirtualServicesPaginator

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

                                                                                                                                                                                            ListVirtualServicesPaginator is a paginator for ListVirtualServices

                                                                                                                                                                                            func NewListVirtualServicesPaginator

                                                                                                                                                                                            func NewListVirtualServicesPaginator(client ListVirtualServicesAPIClient, params *ListVirtualServicesInput, optFns ...func(*ListVirtualServicesPaginatorOptions)) *ListVirtualServicesPaginator

                                                                                                                                                                                              NewListVirtualServicesPaginator returns a new ListVirtualServicesPaginator

                                                                                                                                                                                              func (*ListVirtualServicesPaginator) HasMorePages

                                                                                                                                                                                              func (p *ListVirtualServicesPaginator) HasMorePages() bool

                                                                                                                                                                                                HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                                func (*ListVirtualServicesPaginator) NextPage

                                                                                                                                                                                                func (p *ListVirtualServicesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListVirtualServicesOutput, error)

                                                                                                                                                                                                  NextPage retrieves the next ListVirtualServices page.

                                                                                                                                                                                                  type ListVirtualServicesPaginatorOptions

                                                                                                                                                                                                  type ListVirtualServicesPaginatorOptions struct {
                                                                                                                                                                                                  	// The maximum number of results returned by ListVirtualServices in paginated
                                                                                                                                                                                                  	// output. When you use this parameter, ListVirtualServices returns only limit
                                                                                                                                                                                                  	// results in a single page along with a nextToken response element. You can see
                                                                                                                                                                                                  	// the remaining results of the initial request by sending another
                                                                                                                                                                                                  	// ListVirtualServices request with the returned nextToken value. This value can be
                                                                                                                                                                                                  	// between 1 and 100. If you don't use this parameter, ListVirtualServices returns
                                                                                                                                                                                                  	// up to 100 results and a nextToken value if applicable.
                                                                                                                                                                                                  	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
                                                                                                                                                                                                  }

                                                                                                                                                                                                    ListVirtualServicesPaginatorOptions is the paginator options for ListVirtualServices

                                                                                                                                                                                                    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 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 to add tags to.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	ResourceArn *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The tags to add to the resource. A tag is an array of key-value pairs. Tag keys
                                                                                                                                                                                                      	// can have a maximum character length of 128 characters, and tag values can have a
                                                                                                                                                                                                      	// maximum length of 256 characters.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	Tags []types.TagRef
                                                                                                                                                                                                      }

                                                                                                                                                                                                      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 to delete tags from.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	ResourceArn *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The keys of the tags to be removed.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	TagKeys []string
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UntagResourceOutput

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

                                                                                                                                                                                                      type UpdateGatewayRouteInput

                                                                                                                                                                                                      type UpdateGatewayRouteInput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the gateway route to update.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	GatewayRouteName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the service mesh that the gateway route resides in.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	MeshName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The new gateway route specification to apply. This overwrites the existing data.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	Spec *types.GatewayRouteSpec
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the virtual gateway that the gateway route is associated with.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	VirtualGatewayName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                                                                                                                      	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                                                                                                                                      	ClientToken *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                                                                                                                      	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                                                                                                                      	// more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                                      	MeshOwner *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateGatewayRouteOutput

                                                                                                                                                                                                      type UpdateGatewayRouteOutput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// A full description of the gateway route that was updated.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	GatewayRoute *types.GatewayRouteData
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateMeshInput

                                                                                                                                                                                                      type UpdateMeshInput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the service mesh to update.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	MeshName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                                                                                                                      	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                                                                                                                                      	ClientToken *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The service mesh specification to apply.
                                                                                                                                                                                                      	Spec *types.MeshSpec
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateMeshOutput

                                                                                                                                                                                                      type UpdateMeshOutput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// An object that represents a service mesh returned by a describe operation.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	Mesh *types.MeshData
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateRouteInput

                                                                                                                                                                                                      type UpdateRouteInput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the service mesh that the route resides in.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	MeshName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the route to update.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	RouteName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The new route specification to apply. This overwrites the existing data.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	Spec *types.RouteSpec
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the virtual router that the route is associated with.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	VirtualRouterName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                                                                                                                      	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                                                                                                                                      	ClientToken *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                                                                                                                      	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                                                                                                                      	// more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                                      	MeshOwner *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateRouteOutput

                                                                                                                                                                                                      type UpdateRouteOutput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// A full description of the route that was updated.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	Route *types.RouteData
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateVirtualGatewayInput

                                                                                                                                                                                                      type UpdateVirtualGatewayInput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the service mesh that the virtual gateway resides in.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	MeshName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The new virtual gateway specification to apply. This overwrites the existing
                                                                                                                                                                                                      	// data.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	Spec *types.VirtualGatewaySpec
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the virtual gateway to update.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	VirtualGatewayName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                                                                                                                      	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                                                                                                                                      	ClientToken *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                                                                                                                      	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                                                                                                                      	// more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                                      	MeshOwner *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateVirtualGatewayOutput

                                                                                                                                                                                                      type UpdateVirtualGatewayOutput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// A full description of the virtual gateway that was updated.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	VirtualGateway *types.VirtualGatewayData
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateVirtualNodeInput

                                                                                                                                                                                                      type UpdateVirtualNodeInput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the service mesh that the virtual node resides in.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	MeshName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The new virtual node specification to apply. This overwrites the existing data.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	Spec *types.VirtualNodeSpec
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the virtual node to update.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	VirtualNodeName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                                                                                                                      	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                                                                                                                                      	ClientToken *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                                                                                                                      	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                                                                                                                      	// more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                                      	MeshOwner *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateVirtualNodeOutput

                                                                                                                                                                                                      type UpdateVirtualNodeOutput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// A full description of the virtual node that was updated.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	VirtualNode *types.VirtualNodeData
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateVirtualRouterInput

                                                                                                                                                                                                      type UpdateVirtualRouterInput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the service mesh that the virtual router resides in.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	MeshName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The new virtual router specification to apply. This overwrites the existing
                                                                                                                                                                                                      	// data.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	Spec *types.VirtualRouterSpec
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the virtual router to update.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	VirtualRouterName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                                                                                                                      	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                                                                                                                                      	ClientToken *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                                                                                                                      	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                                                                                                                      	// more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                                      	MeshOwner *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateVirtualRouterOutput

                                                                                                                                                                                                      type UpdateVirtualRouterOutput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// A full description of the virtual router that was updated.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	VirtualRouter *types.VirtualRouterData
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateVirtualServiceInput

                                                                                                                                                                                                      type UpdateVirtualServiceInput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the service mesh that the virtual service resides in.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	MeshName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The new virtual service specification to apply. This overwrites the existing
                                                                                                                                                                                                      	// data.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	Spec *types.VirtualServiceSpec
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The name of the virtual service to update.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	VirtualServiceName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                                                                                                                      	// the request. Up to 36 letters, numbers, hyphens, and underscores are allowed.
                                                                                                                                                                                                      	ClientToken *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The AWS IAM account ID of the service mesh owner. If the account ID is not your
                                                                                                                                                                                                      	// own, then it's the ID of the account that shared the mesh with your account. For
                                                                                                                                                                                                      	// more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                                      	MeshOwner *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type UpdateVirtualServiceOutput

                                                                                                                                                                                                      type UpdateVirtualServiceOutput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// A full description of the virtual service that was updated.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	VirtualService *types.VirtualServiceData
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                      }

                                                                                                                                                                                                      Directories

                                                                                                                                                                                                      Path Synopsis
                                                                                                                                                                                                      internal