Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessLog

type AccessLog interface {
	// contains filtered or unexported methods
}

    An object that represents the access logging information for a virtual node.

    The following types satisfy this interface:

    AccessLogMemberFile
    
    Example (OutputUsage)
    Output:
    
    

    type AccessLogMemberFile

    type AccessLogMemberFile struct {
    	Value FileAccessLog
    }

      The file object to send virtual node access logs to.

      type AwsCloudMapInstanceAttribute

      type AwsCloudMapInstanceAttribute struct {
      
      	// The name of an AWS Cloud Map service instance attribute key. Any AWS Cloud Map
      	// service instance that contains the specified key and value is returned.
      	//
      	// This member is required.
      	Key *string
      
      	// The value of an AWS Cloud Map service instance attribute key. Any AWS Cloud Map
      	// service instance that contains the specified key and value is returned.
      	//
      	// This member is required.
      	Value *string
      }

        An object that represents the AWS Cloud Map attribute information for your virtual node.

        type AwsCloudMapServiceDiscovery

        type AwsCloudMapServiceDiscovery struct {
        
        	// The name of the AWS Cloud Map namespace to use.
        	//
        	// This member is required.
        	NamespaceName *string
        
        	// The name of the AWS Cloud Map service to use.
        	//
        	// This member is required.
        	ServiceName *string
        
        	// A string map that contains attributes with values that you can use to filter
        	// instances by any custom attribute that you specified when you registered the
        	// instance. Only instances that match all of the specified key/value pairs will be
        	// returned.
        	Attributes []AwsCloudMapInstanceAttribute
        }

          An object that represents the AWS Cloud Map service discovery information for your virtual node.

          type Backend

          type Backend interface {
          	// contains filtered or unexported methods
          }

            An object that represents the backends that a virtual node is expected to send outbound traffic to.

            The following types satisfy this interface:

            BackendMemberVirtualService
            
            Example (OutputUsage)
            Output:
            
            

            type BackendDefaults

            type BackendDefaults struct {
            
            	// A reference to an object that represents a client policy.
            	ClientPolicy *ClientPolicy
            }

              An object that represents the default properties for a backend.

              type BackendMemberVirtualService

              type BackendMemberVirtualService struct {
              	Value VirtualServiceBackend
              }

                Specifies a virtual service to use as a backend for a virtual node.

                type BadRequestException

                type BadRequestException struct {
                	Message *string
                }

                  The request syntax was malformed. Check your request syntax and try again.

                  func (*BadRequestException) Error

                  func (e *BadRequestException) Error() string

                  func (*BadRequestException) ErrorCode

                  func (e *BadRequestException) ErrorCode() string

                  func (*BadRequestException) ErrorFault

                  func (e *BadRequestException) ErrorFault() smithy.ErrorFault

                  func (*BadRequestException) ErrorMessage

                  func (e *BadRequestException) ErrorMessage() string

                  type ClientPolicy

                  type ClientPolicy struct {
                  
                  	// A reference to an object that represents a Transport Layer Security (TLS) client
                  	// policy.
                  	Tls *ClientPolicyTls
                  }

                    An object that represents a client policy.

                    type ClientPolicyTls

                    type ClientPolicyTls struct {
                    
                    	// A reference to an object that represents a TLS validation context.
                    	//
                    	// This member is required.
                    	Validation *TlsValidationContext
                    
                    	// Whether the policy is enforced. The default is True, if a value isn't specified.
                    	Enforce *bool
                    
                    	// One or more ports that the policy is enforced for.
                    	Ports []int32
                    }

                      An object that represents a Transport Layer Security (TLS) client policy.

                      type ConflictException

                      type ConflictException struct {
                      	Message *string
                      }

                        The request contains a client token that was used for a previous update resource call with different specifications. Try the request again with a new client token.

                        func (*ConflictException) Error

                        func (e *ConflictException) Error() string

                        func (*ConflictException) ErrorCode

                        func (e *ConflictException) ErrorCode() string

                        func (*ConflictException) ErrorFault

                        func (e *ConflictException) ErrorFault() smithy.ErrorFault

                        func (*ConflictException) ErrorMessage

                        func (e *ConflictException) ErrorMessage() string

                        type DnsServiceDiscovery

                        type DnsServiceDiscovery struct {
                        
                        	// Specifies the DNS service discovery hostname for the virtual node.
                        	//
                        	// This member is required.
                        	Hostname *string
                        }

                          An object that represents the DNS service discovery information for your virtual node.

                          type Duration

                          type Duration struct {
                          
                          	// A unit of time.
                          	Unit DurationUnit
                          
                          	// A number of time units.
                          	Value *int64
                          }

                            An object that represents a duration of time.

                            type DurationUnit

                            type DurationUnit string
                            const (
                            	DurationUnitS  DurationUnit = "s"
                            	DurationUnitMs DurationUnit = "ms"
                            )

                              Enum values for DurationUnit

                              func (DurationUnit) Values

                              func (DurationUnit) Values() []DurationUnit

                                Values returns all known values for DurationUnit. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                type EgressFilter

                                type EgressFilter struct {
                                
                                	// The egress filter type. By default, the type is DROP_ALL, which allows egress
                                	// only from virtual nodes to other defined resources in the service mesh (and any
                                	// traffic to *.amazonaws.com for AWS API calls). You can set the egress filter
                                	// type to ALLOW_ALL to allow egress to any endpoint inside or outside of the
                                	// service mesh.
                                	//
                                	// This member is required.
                                	Type EgressFilterType
                                }

                                  An object that represents the egress filter rules for a service mesh.

                                  type EgressFilterType

                                  type EgressFilterType string
                                  const (
                                  	EgressFilterTypeAllowAll EgressFilterType = "ALLOW_ALL"
                                  	EgressFilterTypeDropAll  EgressFilterType = "DROP_ALL"
                                  )

                                    Enum values for EgressFilterType

                                    func (EgressFilterType) Values

                                      Values returns all known values for EgressFilterType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                      type FileAccessLog

                                      type FileAccessLog struct {
                                      
                                      	// The file path to write access logs to. You can use /dev/stdout to send access
                                      	// logs to standard out and configure your Envoy container to use a log driver,
                                      	// such as awslogs, to export the access logs to a log storage service such as
                                      	// Amazon CloudWatch Logs. You can also specify a path in the Envoy container's
                                      	// file system to write the files to disk. The Envoy process must have write
                                      	// permissions to the path that you specify here. Otherwise, Envoy fails to
                                      	// bootstrap properly.
                                      	//
                                      	// This member is required.
                                      	Path *string
                                      }

                                        An object that represents an access log file.

                                        type ForbiddenException

                                        type ForbiddenException struct {
                                        	Message *string
                                        }

                                          You don't have permissions to perform this action.

                                          func (*ForbiddenException) Error

                                          func (e *ForbiddenException) Error() string

                                          func (*ForbiddenException) ErrorCode

                                          func (e *ForbiddenException) ErrorCode() string

                                          func (*ForbiddenException) ErrorFault

                                          func (e *ForbiddenException) ErrorFault() smithy.ErrorFault

                                          func (*ForbiddenException) ErrorMessage

                                          func (e *ForbiddenException) ErrorMessage() string

                                          type GatewayRouteData

                                          type GatewayRouteData struct {
                                          
                                          	// The name of the gateway route.
                                          	//
                                          	// This member is required.
                                          	GatewayRouteName *string
                                          
                                          	// The name of the service mesh that the resource resides in.
                                          	//
                                          	// This member is required.
                                          	MeshName *string
                                          
                                          	// An object that represents metadata for a resource.
                                          	//
                                          	// This member is required.
                                          	Metadata *ResourceMetadata
                                          
                                          	// The specifications of the gateway route.
                                          	//
                                          	// This member is required.
                                          	Spec *GatewayRouteSpec
                                          
                                          	// The status of the gateway route.
                                          	//
                                          	// This member is required.
                                          	Status *GatewayRouteStatus
                                          
                                          	// The virtual gateway that the gateway route is associated with.
                                          	//
                                          	// This member is required.
                                          	VirtualGatewayName *string
                                          }

                                            An object that represents a gateway route returned by a describe operation.

                                            type GatewayRouteRef

                                            type GatewayRouteRef struct {
                                            
                                            	// The full Amazon Resource Name (ARN) for the gateway route.
                                            	//
                                            	// This member is required.
                                            	Arn *string
                                            
                                            	// The Unix epoch timestamp in seconds for when the resource was created.
                                            	//
                                            	// This member is required.
                                            	CreatedAt *time.Time
                                            
                                            	// The name of the gateway route.
                                            	//
                                            	// This member is required.
                                            	GatewayRouteName *string
                                            
                                            	// The Unix epoch timestamp in seconds for when the resource was last updated.
                                            	//
                                            	// This member is required.
                                            	LastUpdatedAt *time.Time
                                            
                                            	// The name of the service mesh that the resource resides in.
                                            	//
                                            	// 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).
                                            	//
                                            	// This member is required.
                                            	MeshOwner *string
                                            
                                            	// The AWS IAM account ID of the resource owner. If the account ID is not your own,
                                            	// then it's the ID of the mesh owner or of another account that the mesh is shared
                                            	// with. For more information about mesh sharing, see Working with shared meshes
                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                            	//
                                            	// This member is required.
                                            	ResourceOwner *string
                                            
                                            	// The version of the resource. Resources are created at version 1, and this
                                            	// version is incremented each time that they're updated.
                                            	//
                                            	// This member is required.
                                            	Version *int64
                                            
                                            	// The virtual gateway that the gateway route is associated with.
                                            	//
                                            	// This member is required.
                                            	VirtualGatewayName *string
                                            }

                                              An object that represents a gateway route returned by a list operation.

                                              type GatewayRouteSpec

                                              type GatewayRouteSpec struct {
                                              
                                              	// An object that represents the specification of a gRPC gateway route.
                                              	GrpcRoute *GrpcGatewayRoute
                                              
                                              	// An object that represents the specification of an HTTP/2 gateway route.
                                              	Http2Route *HttpGatewayRoute
                                              
                                              	// An object that represents the specification of an HTTP gateway route.
                                              	HttpRoute *HttpGatewayRoute
                                              }

                                                An object that represents a gateway route specification. Specify one gateway route type.

                                                type GatewayRouteStatus

                                                type GatewayRouteStatus struct {
                                                
                                                	// The current status for the gateway route.
                                                	//
                                                	// This member is required.
                                                	Status GatewayRouteStatusCode
                                                }

                                                  An object that represents the current status of a gateway route.

                                                  type GatewayRouteStatusCode

                                                  type GatewayRouteStatusCode string
                                                  const (
                                                  	GatewayRouteStatusCodeActive   GatewayRouteStatusCode = "ACTIVE"
                                                  	GatewayRouteStatusCodeInactive GatewayRouteStatusCode = "INACTIVE"
                                                  	GatewayRouteStatusCodeDeleted  GatewayRouteStatusCode = "DELETED"
                                                  )

                                                    Enum values for GatewayRouteStatusCode

                                                    func (GatewayRouteStatusCode) Values

                                                      Values returns all known values for GatewayRouteStatusCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                      type GatewayRouteTarget

                                                      type GatewayRouteTarget struct {
                                                      
                                                      	// An object that represents a virtual service gateway route target.
                                                      	//
                                                      	// This member is required.
                                                      	VirtualService *GatewayRouteVirtualService
                                                      }

                                                        An object that represents a gateway route target.

                                                        type GatewayRouteVirtualService

                                                        type GatewayRouteVirtualService struct {
                                                        
                                                        	// The name of the virtual service that traffic is routed to.
                                                        	//
                                                        	// This member is required.
                                                        	VirtualServiceName *string
                                                        }

                                                          An object that represents the virtual service that traffic is routed to.

                                                          type GrpcGatewayRoute

                                                          type GrpcGatewayRoute struct {
                                                          
                                                          	// An object that represents the action to take if a match is determined.
                                                          	//
                                                          	// This member is required.
                                                          	Action *GrpcGatewayRouteAction
                                                          
                                                          	// An object that represents the criteria for determining a request match.
                                                          	//
                                                          	// This member is required.
                                                          	Match *GrpcGatewayRouteMatch
                                                          }

                                                            An object that represents a gRPC gateway route.

                                                            type GrpcGatewayRouteAction

                                                            type GrpcGatewayRouteAction struct {
                                                            
                                                            	// An object that represents the target that traffic is routed to when a request
                                                            	// matches the gateway route.
                                                            	//
                                                            	// This member is required.
                                                            	Target *GatewayRouteTarget
                                                            }

                                                              An object that represents the action to take if a match is determined.

                                                              type GrpcGatewayRouteMatch

                                                              type GrpcGatewayRouteMatch struct {
                                                              
                                                              	// The fully qualified domain name for the service to match from the request.
                                                              	ServiceName *string
                                                              }

                                                                An object that represents the criteria for determining a request match.

                                                                type GrpcRetryPolicy

                                                                type GrpcRetryPolicy struct {
                                                                
                                                                	// The maximum number of retry attempts.
                                                                	//
                                                                	// This member is required.
                                                                	MaxRetries *int64
                                                                
                                                                	// An object that represents a duration of time.
                                                                	//
                                                                	// This member is required.
                                                                	PerRetryTimeout *Duration
                                                                
                                                                	// Specify at least one of the valid values.
                                                                	GrpcRetryEvents []GrpcRetryPolicyEvent
                                                                
                                                                	// Specify at least one of the following values.
                                                                	//
                                                                	// * server-error – HTTP status
                                                                	// codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511
                                                                	//
                                                                	// * gateway-error
                                                                	// – HTTP status codes 502, 503, and 504
                                                                	//
                                                                	// * client-error – HTTP status code 409
                                                                	//
                                                                	// *
                                                                	// stream-error – Retry on refused stream
                                                                	HttpRetryEvents []string
                                                                
                                                                	// Specify a valid value.
                                                                	TcpRetryEvents []TcpRetryPolicyEvent
                                                                }

                                                                  An object that represents a retry policy. Specify at least one value for at least one of the types of RetryEvents, a value for maxRetries, and a value for perRetryTimeout.

                                                                  type GrpcRetryPolicyEvent

                                                                  type GrpcRetryPolicyEvent string
                                                                  const (
                                                                  	GrpcRetryPolicyEventCancelled         GrpcRetryPolicyEvent = "cancelled"
                                                                  	GrpcRetryPolicyEventDeadlineExceeded  GrpcRetryPolicyEvent = "deadline-exceeded"
                                                                  	GrpcRetryPolicyEventInternal          GrpcRetryPolicyEvent = "internal"
                                                                  	GrpcRetryPolicyEventResourceExhausted GrpcRetryPolicyEvent = "resource-exhausted"
                                                                  	GrpcRetryPolicyEventUnavailable       GrpcRetryPolicyEvent = "unavailable"
                                                                  )

                                                                    Enum values for GrpcRetryPolicyEvent

                                                                    func (GrpcRetryPolicyEvent) Values

                                                                      Values returns all known values for GrpcRetryPolicyEvent. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                      type GrpcRoute

                                                                      type GrpcRoute struct {
                                                                      
                                                                      	// An object that represents the action to take if a match is determined.
                                                                      	//
                                                                      	// This member is required.
                                                                      	Action *GrpcRouteAction
                                                                      
                                                                      	// An object that represents the criteria for determining a request match.
                                                                      	//
                                                                      	// This member is required.
                                                                      	Match *GrpcRouteMatch
                                                                      
                                                                      	// An object that represents a retry policy.
                                                                      	RetryPolicy *GrpcRetryPolicy
                                                                      
                                                                      	// An object that represents types of timeouts.
                                                                      	Timeout *GrpcTimeout
                                                                      }

                                                                        An object that represents a gRPC route type.

                                                                        type GrpcRouteAction

                                                                        type GrpcRouteAction struct {
                                                                        
                                                                        	// An object that represents the targets that traffic is routed to when a request
                                                                        	// matches the route.
                                                                        	//
                                                                        	// This member is required.
                                                                        	WeightedTargets []WeightedTarget
                                                                        }

                                                                          An object that represents the action to take if a match is determined.

                                                                          type GrpcRouteMatch

                                                                          type GrpcRouteMatch struct {
                                                                          
                                                                          	// An object that represents the data to match from the request.
                                                                          	Metadata []GrpcRouteMetadata
                                                                          
                                                                          	// The method name to match from the request. If you specify a name, you must also
                                                                          	// specify a serviceName.
                                                                          	MethodName *string
                                                                          
                                                                          	// The fully qualified domain name for the service to match from the request.
                                                                          	ServiceName *string
                                                                          }

                                                                            An object that represents the criteria for determining a request match.

                                                                            type GrpcRouteMetadata

                                                                            type GrpcRouteMetadata struct {
                                                                            
                                                                            	// The name of the route.
                                                                            	//
                                                                            	// This member is required.
                                                                            	Name *string
                                                                            
                                                                            	// Specify True to match anything except the match criteria. The default value is
                                                                            	// False.
                                                                            	Invert *bool
                                                                            
                                                                            	// An object that represents the data to match from the request.
                                                                            	Match GrpcRouteMetadataMatchMethod
                                                                            }

                                                                              An object that represents the match metadata for the route.

                                                                              type GrpcRouteMetadataMatchMethod

                                                                              type GrpcRouteMetadataMatchMethod interface {
                                                                              	// contains filtered or unexported methods
                                                                              }

                                                                                An object that represents the match method. Specify one of the match values.

                                                                                The following types satisfy this interface:

                                                                                GrpcRouteMetadataMatchMethodMemberExact
                                                                                GrpcRouteMetadataMatchMethodMemberRegex
                                                                                GrpcRouteMetadataMatchMethodMemberRange
                                                                                GrpcRouteMetadataMatchMethodMemberPrefix
                                                                                GrpcRouteMetadataMatchMethodMemberSuffix
                                                                                
                                                                                Example (OutputUsage)
                                                                                Output:
                                                                                
                                                                                

                                                                                type GrpcRouteMetadataMatchMethodMemberExact

                                                                                type GrpcRouteMetadataMatchMethodMemberExact struct {
                                                                                	Value string
                                                                                }

                                                                                  The value sent by the client must match the specified value exactly.

                                                                                  type GrpcRouteMetadataMatchMethodMemberPrefix

                                                                                  type GrpcRouteMetadataMatchMethodMemberPrefix struct {
                                                                                  	Value string
                                                                                  }

                                                                                    The value sent by the client must begin with the specified characters.

                                                                                    type GrpcRouteMetadataMatchMethodMemberRange

                                                                                    type GrpcRouteMetadataMatchMethodMemberRange struct {
                                                                                    	Value MatchRange
                                                                                    }

                                                                                      An object that represents the range of values to match on.

                                                                                      type GrpcRouteMetadataMatchMethodMemberRegex

                                                                                      type GrpcRouteMetadataMatchMethodMemberRegex struct {
                                                                                      	Value string
                                                                                      }

                                                                                        The value sent by the client must include the specified characters.

                                                                                        type GrpcRouteMetadataMatchMethodMemberSuffix

                                                                                        type GrpcRouteMetadataMatchMethodMemberSuffix struct {
                                                                                        	Value string
                                                                                        }

                                                                                          The value sent by the client must end with the specified characters.

                                                                                          type GrpcTimeout

                                                                                          type GrpcTimeout struct {
                                                                                          
                                                                                          	// An object that represents an idle timeout. An idle timeout bounds the amount of
                                                                                          	// time that a connection may be idle. The default value is none.
                                                                                          	Idle *Duration
                                                                                          
                                                                                          	// An object that represents a per request timeout. The default value is 15
                                                                                          	// seconds. If you set a higher timeout, then make sure that the higher value is
                                                                                          	// set for each App Mesh resource in a conversation. For example, if a virtual node
                                                                                          	// backend uses a virtual router provider to route to another virtual node, then
                                                                                          	// the timeout should be greater than 15 seconds for the source and destination
                                                                                          	// virtual node and the route.
                                                                                          	PerRequest *Duration
                                                                                          }

                                                                                            An object that represents types of timeouts.

                                                                                            type HeaderMatchMethod

                                                                                            type HeaderMatchMethod interface {
                                                                                            	// contains filtered or unexported methods
                                                                                            }

                                                                                              An object that represents the method and value to match with the header value sent in a request. Specify one match method.

                                                                                              The following types satisfy this interface:

                                                                                              HeaderMatchMethodMemberExact
                                                                                              HeaderMatchMethodMemberRegex
                                                                                              HeaderMatchMethodMemberRange
                                                                                              HeaderMatchMethodMemberPrefix
                                                                                              HeaderMatchMethodMemberSuffix
                                                                                              
                                                                                              Example (OutputUsage)
                                                                                              Output:
                                                                                              
                                                                                              

                                                                                              type HeaderMatchMethodMemberExact

                                                                                              type HeaderMatchMethodMemberExact struct {
                                                                                              	Value string
                                                                                              }

                                                                                                The value sent by the client must match the specified value exactly.

                                                                                                type HeaderMatchMethodMemberPrefix

                                                                                                type HeaderMatchMethodMemberPrefix struct {
                                                                                                	Value string
                                                                                                }

                                                                                                  The value sent by the client must begin with the specified characters.

                                                                                                  type HeaderMatchMethodMemberRange

                                                                                                  type HeaderMatchMethodMemberRange struct {
                                                                                                  	Value MatchRange
                                                                                                  }

                                                                                                    An object that represents the range of values to match on.

                                                                                                    type HeaderMatchMethodMemberRegex

                                                                                                    type HeaderMatchMethodMemberRegex struct {
                                                                                                    	Value string
                                                                                                    }

                                                                                                      The value sent by the client must include the specified characters.

                                                                                                      type HeaderMatchMethodMemberSuffix

                                                                                                      type HeaderMatchMethodMemberSuffix struct {
                                                                                                      	Value string
                                                                                                      }

                                                                                                        The value sent by the client must end with the specified characters.

                                                                                                        type HealthCheckPolicy

                                                                                                        type HealthCheckPolicy struct {
                                                                                                        
                                                                                                        	// The number of consecutive successful health checks that must occur before
                                                                                                        	// declaring listener healthy.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	HealthyThreshold int32
                                                                                                        
                                                                                                        	// The time period in milliseconds between each health check execution.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	IntervalMillis *int64
                                                                                                        
                                                                                                        	// The protocol for the health check request. If you specify grpc, then your
                                                                                                        	// service must conform to the GRPC Health Checking Protocol
                                                                                                        	// (https://github.com/grpc/grpc/blob/master/doc/health-checking.md).
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Protocol PortProtocol
                                                                                                        
                                                                                                        	// The amount of time to wait when receiving a response from the health check, in
                                                                                                        	// milliseconds.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	TimeoutMillis *int64
                                                                                                        
                                                                                                        	// The number of consecutive failed health checks that must occur before declaring
                                                                                                        	// a virtual node unhealthy.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	UnhealthyThreshold int32
                                                                                                        
                                                                                                        	// The destination path for the health check request. This value is only used if
                                                                                                        	// the specified protocol is HTTP or HTTP/2. For any other protocol, this value is
                                                                                                        	// ignored.
                                                                                                        	Path *string
                                                                                                        
                                                                                                        	// The destination port for the health check request. This port must match the port
                                                                                                        	// defined in the PortMapping for the listener.
                                                                                                        	Port int32
                                                                                                        }

                                                                                                          An object that represents the health check policy for a virtual node's listener.

                                                                                                          type HttpGatewayRoute

                                                                                                          type HttpGatewayRoute struct {
                                                                                                          
                                                                                                          	// An object that represents the action to take if a match is determined.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Action *HttpGatewayRouteAction
                                                                                                          
                                                                                                          	// An object that represents the criteria for determining a request match.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Match *HttpGatewayRouteMatch
                                                                                                          }

                                                                                                            An object that represents an HTTP gateway route.

                                                                                                            type HttpGatewayRouteAction

                                                                                                            type HttpGatewayRouteAction struct {
                                                                                                            
                                                                                                            	// An object that represents the target that traffic is routed to when a request
                                                                                                            	// matches the gateway route.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	Target *GatewayRouteTarget
                                                                                                            }

                                                                                                              An object that represents the action to take if a match is determined.

                                                                                                              type HttpGatewayRouteMatch

                                                                                                              type HttpGatewayRouteMatch struct {
                                                                                                              
                                                                                                              	// Specifies the path to match requests with. This parameter must always start with
                                                                                                              	// /, which by itself matches all requests to the virtual service name. You can
                                                                                                              	// also match for path-based routing of requests. For example, if your virtual
                                                                                                              	// service name is my-service.local and you want the route to match requests to
                                                                                                              	// my-service.local/metrics, your prefix should be /metrics.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	Prefix *string
                                                                                                              }

                                                                                                                An object that represents the criteria for determining a request match.

                                                                                                                type HttpMethod

                                                                                                                type HttpMethod string
                                                                                                                const (
                                                                                                                	HttpMethodGet     HttpMethod = "GET"
                                                                                                                	HttpMethodHead    HttpMethod = "HEAD"
                                                                                                                	HttpMethodPost    HttpMethod = "POST"
                                                                                                                	HttpMethodPut     HttpMethod = "PUT"
                                                                                                                	HttpMethodDelete  HttpMethod = "DELETE"
                                                                                                                	HttpMethodConnect HttpMethod = "CONNECT"
                                                                                                                	HttpMethodOptions HttpMethod = "OPTIONS"
                                                                                                                	HttpMethodTrace   HttpMethod = "TRACE"
                                                                                                                	HttpMethodPatch   HttpMethod = "PATCH"
                                                                                                                )

                                                                                                                  Enum values for HttpMethod

                                                                                                                  func (HttpMethod) Values

                                                                                                                  func (HttpMethod) Values() []HttpMethod

                                                                                                                    Values returns all known values for HttpMethod. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                    type HttpRetryPolicy

                                                                                                                    type HttpRetryPolicy struct {
                                                                                                                    
                                                                                                                    	// The maximum number of retry attempts.
                                                                                                                    	//
                                                                                                                    	// This member is required.
                                                                                                                    	MaxRetries *int64
                                                                                                                    
                                                                                                                    	// An object that represents a duration of time.
                                                                                                                    	//
                                                                                                                    	// This member is required.
                                                                                                                    	PerRetryTimeout *Duration
                                                                                                                    
                                                                                                                    	// Specify at least one of the following values.
                                                                                                                    	//
                                                                                                                    	// * server-error – HTTP status
                                                                                                                    	// codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511
                                                                                                                    	//
                                                                                                                    	// * gateway-error
                                                                                                                    	// – HTTP status codes 502, 503, and 504
                                                                                                                    	//
                                                                                                                    	// * client-error – HTTP status code 409
                                                                                                                    	//
                                                                                                                    	// *
                                                                                                                    	// stream-error – Retry on refused stream
                                                                                                                    	HttpRetryEvents []string
                                                                                                                    
                                                                                                                    	// Specify a valid value.
                                                                                                                    	TcpRetryEvents []TcpRetryPolicyEvent
                                                                                                                    }

                                                                                                                      An object that represents a retry policy. Specify at least one value for at least one of the types of RetryEvents, a value for maxRetries, and a value for perRetryTimeout.

                                                                                                                      type HttpRoute

                                                                                                                      type HttpRoute struct {
                                                                                                                      
                                                                                                                      	// An object that represents the action to take if a match is determined.
                                                                                                                      	//
                                                                                                                      	// This member is required.
                                                                                                                      	Action *HttpRouteAction
                                                                                                                      
                                                                                                                      	// An object that represents the criteria for determining a request match.
                                                                                                                      	//
                                                                                                                      	// This member is required.
                                                                                                                      	Match *HttpRouteMatch
                                                                                                                      
                                                                                                                      	// An object that represents a retry policy.
                                                                                                                      	RetryPolicy *HttpRetryPolicy
                                                                                                                      
                                                                                                                      	// An object that represents types of timeouts.
                                                                                                                      	Timeout *HttpTimeout
                                                                                                                      }

                                                                                                                        An object that represents an HTTP or HTTP/2 route type.

                                                                                                                        type HttpRouteAction

                                                                                                                        type HttpRouteAction struct {
                                                                                                                        
                                                                                                                        	// An object that represents the targets that traffic is routed to when a request
                                                                                                                        	// matches the route.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	WeightedTargets []WeightedTarget
                                                                                                                        }

                                                                                                                          An object that represents the action to take if a match is determined.

                                                                                                                          type HttpRouteHeader

                                                                                                                          type HttpRouteHeader struct {
                                                                                                                          
                                                                                                                          	// A name for the HTTP header in the client request that will be matched on.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Name *string
                                                                                                                          
                                                                                                                          	// Specify True to match anything except the match criteria. The default value is
                                                                                                                          	// False.
                                                                                                                          	Invert *bool
                                                                                                                          
                                                                                                                          	// The HeaderMatchMethod object.
                                                                                                                          	Match HeaderMatchMethod
                                                                                                                          }

                                                                                                                            An object that represents the HTTP header in the request.

                                                                                                                            type HttpRouteMatch

                                                                                                                            type HttpRouteMatch struct {
                                                                                                                            
                                                                                                                            	// Specifies the path to match requests with. This parameter must always start with
                                                                                                                            	// /, which by itself matches all requests to the virtual service name. You can
                                                                                                                            	// also match for path-based routing of requests. For example, if your virtual
                                                                                                                            	// service name is my-service.local and you want the route to match requests to
                                                                                                                            	// my-service.local/metrics, your prefix should be /metrics.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	Prefix *string
                                                                                                                            
                                                                                                                            	// An object that represents the client request headers to match on.
                                                                                                                            	Headers []HttpRouteHeader
                                                                                                                            
                                                                                                                            	// The client request method to match on. Specify only one.
                                                                                                                            	Method HttpMethod
                                                                                                                            
                                                                                                                            	// The client request scheme to match on. Specify only one.
                                                                                                                            	Scheme HttpScheme
                                                                                                                            }

                                                                                                                              An object that represents the requirements for a route to match HTTP requests for a virtual router.

                                                                                                                              type HttpScheme

                                                                                                                              type HttpScheme string
                                                                                                                              const (
                                                                                                                              	HttpSchemeHttp  HttpScheme = "http"
                                                                                                                              	HttpSchemeHttps HttpScheme = "https"
                                                                                                                              )

                                                                                                                                Enum values for HttpScheme

                                                                                                                                func (HttpScheme) Values

                                                                                                                                func (HttpScheme) Values() []HttpScheme

                                                                                                                                  Values returns all known values for HttpScheme. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                  type HttpTimeout

                                                                                                                                  type HttpTimeout struct {
                                                                                                                                  
                                                                                                                                  	// An object that represents a duration of time.
                                                                                                                                  	Idle *Duration
                                                                                                                                  
                                                                                                                                  	// An object that represents a duration of time.
                                                                                                                                  	PerRequest *Duration
                                                                                                                                  }

                                                                                                                                    An object that represents types of timeouts.

                                                                                                                                    type InternalServerErrorException

                                                                                                                                    type InternalServerErrorException struct {
                                                                                                                                    	Message *string
                                                                                                                                    }

                                                                                                                                      The request processing has failed because of an unknown error, exception, or failure.

                                                                                                                                      func (*InternalServerErrorException) Error

                                                                                                                                      func (*InternalServerErrorException) ErrorCode

                                                                                                                                      func (e *InternalServerErrorException) ErrorCode() string

                                                                                                                                      func (*InternalServerErrorException) ErrorFault

                                                                                                                                      func (*InternalServerErrorException) ErrorMessage

                                                                                                                                      func (e *InternalServerErrorException) ErrorMessage() string

                                                                                                                                      type LimitExceededException

                                                                                                                                      type LimitExceededException struct {
                                                                                                                                      	Message *string
                                                                                                                                      }

                                                                                                                                        You have exceeded a service limit for your account. For more information, see Service Limits (https://docs.aws.amazon.com/app-mesh/latest/userguide/service-quotas.html) in the AWS App Mesh User Guide.

                                                                                                                                        func (*LimitExceededException) Error

                                                                                                                                        func (e *LimitExceededException) Error() string

                                                                                                                                        func (*LimitExceededException) ErrorCode

                                                                                                                                        func (e *LimitExceededException) ErrorCode() string

                                                                                                                                        func (*LimitExceededException) ErrorFault

                                                                                                                                        func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                                                                                                                        func (*LimitExceededException) ErrorMessage

                                                                                                                                        func (e *LimitExceededException) ErrorMessage() string

                                                                                                                                        type Listener

                                                                                                                                        type Listener struct {
                                                                                                                                        
                                                                                                                                        	// The port mapping information for the listener.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	PortMapping *PortMapping
                                                                                                                                        
                                                                                                                                        	// The health check information for the listener.
                                                                                                                                        	HealthCheck *HealthCheckPolicy
                                                                                                                                        
                                                                                                                                        	// An object that represents timeouts for different protocols.
                                                                                                                                        	Timeout ListenerTimeout
                                                                                                                                        
                                                                                                                                        	// A reference to an object that represents the Transport Layer Security (TLS)
                                                                                                                                        	// properties for a listener.
                                                                                                                                        	Tls *ListenerTls
                                                                                                                                        }

                                                                                                                                          An object that represents a listener for a virtual node.

                                                                                                                                          type ListenerTimeout

                                                                                                                                          type ListenerTimeout interface {
                                                                                                                                          	// contains filtered or unexported methods
                                                                                                                                          }

                                                                                                                                            An object that represents timeouts for different protocols.

                                                                                                                                            The following types satisfy this interface:

                                                                                                                                            ListenerTimeoutMemberTcp
                                                                                                                                            ListenerTimeoutMemberHttp
                                                                                                                                            ListenerTimeoutMemberHttp2
                                                                                                                                            ListenerTimeoutMemberGrpc
                                                                                                                                            
                                                                                                                                            Example (OutputUsage)
                                                                                                                                            Output:
                                                                                                                                            
                                                                                                                                            

                                                                                                                                            type ListenerTimeoutMemberGrpc

                                                                                                                                            type ListenerTimeoutMemberGrpc struct {
                                                                                                                                            	Value GrpcTimeout
                                                                                                                                            }

                                                                                                                                              An object that represents types of timeouts.

                                                                                                                                              type ListenerTimeoutMemberHttp

                                                                                                                                              type ListenerTimeoutMemberHttp struct {
                                                                                                                                              	Value HttpTimeout
                                                                                                                                              }

                                                                                                                                                An object that represents types of timeouts.

                                                                                                                                                type ListenerTimeoutMemberHttp2

                                                                                                                                                type ListenerTimeoutMemberHttp2 struct {
                                                                                                                                                	Value HttpTimeout
                                                                                                                                                }

                                                                                                                                                  An object that represents types of timeouts.

                                                                                                                                                  type ListenerTimeoutMemberTcp

                                                                                                                                                  type ListenerTimeoutMemberTcp struct {
                                                                                                                                                  	Value TcpTimeout
                                                                                                                                                  }

                                                                                                                                                    An object that represents types of timeouts.

                                                                                                                                                    type ListenerTls

                                                                                                                                                    type ListenerTls struct {
                                                                                                                                                    
                                                                                                                                                    	// A reference to an object that represents a listener's TLS certificate.
                                                                                                                                                    	//
                                                                                                                                                    	// This member is required.
                                                                                                                                                    	Certificate ListenerTlsCertificate
                                                                                                                                                    
                                                                                                                                                    	// Specify one of the following modes.
                                                                                                                                                    	//
                                                                                                                                                    	// * STRICT – Listener only accepts
                                                                                                                                                    	// connections with TLS enabled.
                                                                                                                                                    	//
                                                                                                                                                    	// * PERMISSIVE – Listener accepts connections with
                                                                                                                                                    	// or without TLS enabled.
                                                                                                                                                    	//
                                                                                                                                                    	// * DISABLED – Listener only accepts connections without
                                                                                                                                                    	// TLS.
                                                                                                                                                    	//
                                                                                                                                                    	// This member is required.
                                                                                                                                                    	Mode ListenerTlsMode
                                                                                                                                                    }

                                                                                                                                                      An object that represents the Transport Layer Security (TLS) properties for a listener.

                                                                                                                                                      type ListenerTlsAcmCertificate

                                                                                                                                                      type ListenerTlsAcmCertificate struct {
                                                                                                                                                      
                                                                                                                                                      	// The Amazon Resource Name (ARN) for the certificate. The certificate must meet
                                                                                                                                                      	// specific requirements and you must have proxy authorization enabled. For more
                                                                                                                                                      	// information, see Transport Layer Security (TLS)
                                                                                                                                                      	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/tls.html#virtual-node-tls-prerequisites).
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	CertificateArn *string
                                                                                                                                                      }

                                                                                                                                                        An object that represents an AWS Certicate Manager (ACM) certificate.

                                                                                                                                                        type ListenerTlsCertificate

                                                                                                                                                        type ListenerTlsCertificate interface {
                                                                                                                                                        	// contains filtered or unexported methods
                                                                                                                                                        }

                                                                                                                                                          An object that represents a listener's Transport Layer Security (TLS) certificate.

                                                                                                                                                          The following types satisfy this interface:

                                                                                                                                                          ListenerTlsCertificateMemberAcm
                                                                                                                                                          ListenerTlsCertificateMemberFile
                                                                                                                                                          
                                                                                                                                                          Example (OutputUsage)
                                                                                                                                                          Output:
                                                                                                                                                          
                                                                                                                                                          

                                                                                                                                                          type ListenerTlsCertificateMemberAcm

                                                                                                                                                          type ListenerTlsCertificateMemberAcm struct {
                                                                                                                                                          	Value ListenerTlsAcmCertificate
                                                                                                                                                          }

                                                                                                                                                            A reference to an object that represents an AWS Certicate Manager (ACM) certificate.

                                                                                                                                                            type ListenerTlsCertificateMemberFile

                                                                                                                                                            type ListenerTlsCertificateMemberFile struct {
                                                                                                                                                            	Value ListenerTlsFileCertificate
                                                                                                                                                            }

                                                                                                                                                              A reference to an object that represents a local file certificate.

                                                                                                                                                              type ListenerTlsFileCertificate

                                                                                                                                                              type ListenerTlsFileCertificate struct {
                                                                                                                                                              
                                                                                                                                                              	// The certificate chain for the certificate.
                                                                                                                                                              	//
                                                                                                                                                              	// This member is required.
                                                                                                                                                              	CertificateChain *string
                                                                                                                                                              
                                                                                                                                                              	// The private key for a certificate stored on the file system of the virtual node
                                                                                                                                                              	// that the proxy is running on.
                                                                                                                                                              	//
                                                                                                                                                              	// This member is required.
                                                                                                                                                              	PrivateKey *string
                                                                                                                                                              }

                                                                                                                                                                An object that represents a local file certificate. The certificate must meet specific requirements and you must have proxy authorization enabled. For more information, see Transport Layer Security (TLS) (https://docs.aws.amazon.com/app-mesh/latest/userguide/tls.html#virtual-node-tls-prerequisites).

                                                                                                                                                                type ListenerTlsMode

                                                                                                                                                                type ListenerTlsMode string
                                                                                                                                                                const (
                                                                                                                                                                	ListenerTlsModeStrict     ListenerTlsMode = "STRICT"
                                                                                                                                                                	ListenerTlsModePermissive ListenerTlsMode = "PERMISSIVE"
                                                                                                                                                                	ListenerTlsModeDisabled   ListenerTlsMode = "DISABLED"
                                                                                                                                                                )

                                                                                                                                                                  Enum values for ListenerTlsMode

                                                                                                                                                                  func (ListenerTlsMode) Values

                                                                                                                                                                  func (ListenerTlsMode) Values() []ListenerTlsMode

                                                                                                                                                                    Values returns all known values for ListenerTlsMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                    type Logging

                                                                                                                                                                    type Logging struct {
                                                                                                                                                                    
                                                                                                                                                                    	// The access log configuration for a virtual node.
                                                                                                                                                                    	AccessLog AccessLog
                                                                                                                                                                    }

                                                                                                                                                                      An object that represents the logging information for a virtual node.

                                                                                                                                                                      type MatchRange

                                                                                                                                                                      type MatchRange struct {
                                                                                                                                                                      
                                                                                                                                                                      	// The end of the range.
                                                                                                                                                                      	//
                                                                                                                                                                      	// This member is required.
                                                                                                                                                                      	End *int64
                                                                                                                                                                      
                                                                                                                                                                      	// The start of the range.
                                                                                                                                                                      	//
                                                                                                                                                                      	// This member is required.
                                                                                                                                                                      	Start *int64
                                                                                                                                                                      }

                                                                                                                                                                        An object that represents the range of values to match on. The first character of the range is included in the range, though the last character is not. For example, if the range specified were 1-100, only values 1-99 would be matched.

                                                                                                                                                                        type MeshData

                                                                                                                                                                        type MeshData struct {
                                                                                                                                                                        
                                                                                                                                                                        	// The name of the service mesh.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	MeshName *string
                                                                                                                                                                        
                                                                                                                                                                        	// The associated metadata for the service mesh.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	Metadata *ResourceMetadata
                                                                                                                                                                        
                                                                                                                                                                        	// The associated specification for the service mesh.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	Spec *MeshSpec
                                                                                                                                                                        
                                                                                                                                                                        	// The status of the service mesh.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	Status *MeshStatus
                                                                                                                                                                        }

                                                                                                                                                                          An object that represents a service mesh returned by a describe operation.

                                                                                                                                                                          type MeshRef

                                                                                                                                                                          type MeshRef struct {
                                                                                                                                                                          
                                                                                                                                                                          	// The full Amazon Resource Name (ARN) of the service mesh.
                                                                                                                                                                          	//
                                                                                                                                                                          	// This member is required.
                                                                                                                                                                          	Arn *string
                                                                                                                                                                          
                                                                                                                                                                          	// The Unix epoch timestamp in seconds for when the resource was created.
                                                                                                                                                                          	//
                                                                                                                                                                          	// This member is required.
                                                                                                                                                                          	CreatedAt *time.Time
                                                                                                                                                                          
                                                                                                                                                                          	// The Unix epoch timestamp in seconds for when the resource was last updated.
                                                                                                                                                                          	//
                                                                                                                                                                          	// This member is required.
                                                                                                                                                                          	LastUpdatedAt *time.Time
                                                                                                                                                                          
                                                                                                                                                                          	// The name of the service mesh.
                                                                                                                                                                          	//
                                                                                                                                                                          	// 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).
                                                                                                                                                                          	//
                                                                                                                                                                          	// This member is required.
                                                                                                                                                                          	MeshOwner *string
                                                                                                                                                                          
                                                                                                                                                                          	// The AWS IAM account ID of the resource owner. If the account ID is not your own,
                                                                                                                                                                          	// then it's the ID of the mesh owner or of another account that the mesh is shared
                                                                                                                                                                          	// with. For more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                          	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                          	//
                                                                                                                                                                          	// This member is required.
                                                                                                                                                                          	ResourceOwner *string
                                                                                                                                                                          
                                                                                                                                                                          	// The version of the resource. Resources are created at version 1, and this
                                                                                                                                                                          	// version is incremented each time that they're updated.
                                                                                                                                                                          	//
                                                                                                                                                                          	// This member is required.
                                                                                                                                                                          	Version *int64
                                                                                                                                                                          }

                                                                                                                                                                            An object that represents a service mesh returned by a list operation.

                                                                                                                                                                            type MeshSpec

                                                                                                                                                                            type MeshSpec struct {
                                                                                                                                                                            
                                                                                                                                                                            	// The egress filter rules for the service mesh.
                                                                                                                                                                            	EgressFilter *EgressFilter
                                                                                                                                                                            }

                                                                                                                                                                              An object that represents the specification of a service mesh.

                                                                                                                                                                              type MeshStatus

                                                                                                                                                                              type MeshStatus struct {
                                                                                                                                                                              
                                                                                                                                                                              	// The current mesh status.
                                                                                                                                                                              	Status MeshStatusCode
                                                                                                                                                                              }

                                                                                                                                                                                An object that represents the status of a service mesh.

                                                                                                                                                                                type MeshStatusCode

                                                                                                                                                                                type MeshStatusCode string
                                                                                                                                                                                const (
                                                                                                                                                                                	MeshStatusCodeActive   MeshStatusCode = "ACTIVE"
                                                                                                                                                                                	MeshStatusCodeInactive MeshStatusCode = "INACTIVE"
                                                                                                                                                                                	MeshStatusCodeDeleted  MeshStatusCode = "DELETED"
                                                                                                                                                                                )

                                                                                                                                                                                  Enum values for MeshStatusCode

                                                                                                                                                                                  func (MeshStatusCode) Values

                                                                                                                                                                                  func (MeshStatusCode) Values() []MeshStatusCode

                                                                                                                                                                                    Values returns all known values for MeshStatusCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                    type NotFoundException

                                                                                                                                                                                    type NotFoundException struct {
                                                                                                                                                                                    	Message *string
                                                                                                                                                                                    }

                                                                                                                                                                                      The specified resource doesn't exist. Check your request syntax and try again.

                                                                                                                                                                                      func (*NotFoundException) Error

                                                                                                                                                                                      func (e *NotFoundException) Error() string

                                                                                                                                                                                      func (*NotFoundException) ErrorCode

                                                                                                                                                                                      func (e *NotFoundException) ErrorCode() string

                                                                                                                                                                                      func (*NotFoundException) ErrorFault

                                                                                                                                                                                      func (e *NotFoundException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                      func (*NotFoundException) ErrorMessage

                                                                                                                                                                                      func (e *NotFoundException) ErrorMessage() string

                                                                                                                                                                                      type PortMapping

                                                                                                                                                                                      type PortMapping struct {
                                                                                                                                                                                      
                                                                                                                                                                                      	// The port used for the port mapping.
                                                                                                                                                                                      	//
                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                      	Port int32
                                                                                                                                                                                      
                                                                                                                                                                                      	// The protocol used for the port mapping. Specify one protocol.
                                                                                                                                                                                      	//
                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                      	Protocol PortProtocol
                                                                                                                                                                                      }

                                                                                                                                                                                        An object that represents a port mapping.

                                                                                                                                                                                        type PortProtocol

                                                                                                                                                                                        type PortProtocol string
                                                                                                                                                                                        const (
                                                                                                                                                                                        	PortProtocolHttp  PortProtocol = "http"
                                                                                                                                                                                        	PortProtocolTcp   PortProtocol = "tcp"
                                                                                                                                                                                        	PortProtocolHttp2 PortProtocol = "http2"
                                                                                                                                                                                        	PortProtocolGrpc  PortProtocol = "grpc"
                                                                                                                                                                                        )

                                                                                                                                                                                          Enum values for PortProtocol

                                                                                                                                                                                          func (PortProtocol) Values

                                                                                                                                                                                          func (PortProtocol) Values() []PortProtocol

                                                                                                                                                                                            Values returns all known values for PortProtocol. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                            type ResourceInUseException

                                                                                                                                                                                            type ResourceInUseException struct {
                                                                                                                                                                                            	Message *string
                                                                                                                                                                                            }

                                                                                                                                                                                              You can't delete the specified resource because it's in use or required by another resource.

                                                                                                                                                                                              func (*ResourceInUseException) Error

                                                                                                                                                                                              func (e *ResourceInUseException) Error() string

                                                                                                                                                                                              func (*ResourceInUseException) ErrorCode

                                                                                                                                                                                              func (e *ResourceInUseException) ErrorCode() string

                                                                                                                                                                                              func (*ResourceInUseException) ErrorFault

                                                                                                                                                                                              func (e *ResourceInUseException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                              func (*ResourceInUseException) ErrorMessage

                                                                                                                                                                                              func (e *ResourceInUseException) ErrorMessage() string

                                                                                                                                                                                              type ResourceMetadata

                                                                                                                                                                                              type ResourceMetadata struct {
                                                                                                                                                                                              
                                                                                                                                                                                              	// The full Amazon Resource Name (ARN) for the resource.
                                                                                                                                                                                              	//
                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                              	Arn *string
                                                                                                                                                                                              
                                                                                                                                                                                              	// The Unix epoch timestamp in seconds for when the resource was created.
                                                                                                                                                                                              	//
                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                              	CreatedAt *time.Time
                                                                                                                                                                                              
                                                                                                                                                                                              	// The Unix epoch timestamp in seconds for when the resource was last updated.
                                                                                                                                                                                              	//
                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                              	LastUpdatedAt *time.Time
                                                                                                                                                                                              
                                                                                                                                                                                              	// 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).
                                                                                                                                                                                              	//
                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                              	MeshOwner *string
                                                                                                                                                                                              
                                                                                                                                                                                              	// The AWS IAM account ID of the resource owner. If the account ID is not your own,
                                                                                                                                                                                              	// then it's the ID of the mesh owner or of another account that the mesh is shared
                                                                                                                                                                                              	// with. For more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                              	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                              	//
                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                              	ResourceOwner *string
                                                                                                                                                                                              
                                                                                                                                                                                              	// The unique identifier for the resource.
                                                                                                                                                                                              	//
                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                              	Uid *string
                                                                                                                                                                                              
                                                                                                                                                                                              	// The version of the resource. Resources are created at version 1, and this
                                                                                                                                                                                              	// version is incremented each time that they're updated.
                                                                                                                                                                                              	//
                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                              	Version *int64
                                                                                                                                                                                              }

                                                                                                                                                                                                An object that represents metadata for a resource.

                                                                                                                                                                                                type RouteData

                                                                                                                                                                                                type RouteData struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The name of the service mesh that the route resides in.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	MeshName *string
                                                                                                                                                                                                
                                                                                                                                                                                                	// The associated metadata for the route.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	Metadata *ResourceMetadata
                                                                                                                                                                                                
                                                                                                                                                                                                	// The name of the route.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	RouteName *string
                                                                                                                                                                                                
                                                                                                                                                                                                	// The specifications of the route.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	Spec *RouteSpec
                                                                                                                                                                                                
                                                                                                                                                                                                	// The status of the route.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	Status *RouteStatus
                                                                                                                                                                                                
                                                                                                                                                                                                	// The virtual router that the route is associated with.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	VirtualRouterName *string
                                                                                                                                                                                                }

                                                                                                                                                                                                  An object that represents a route returned by a describe operation.

                                                                                                                                                                                                  type RouteRef

                                                                                                                                                                                                  type RouteRef struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The full Amazon Resource Name (ARN) for the route.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	Arn *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The Unix epoch timestamp in seconds for when the resource was created.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	CreatedAt *time.Time
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The Unix epoch timestamp in seconds for when the resource was last updated.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	LastUpdatedAt *time.Time
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The name of the service mesh that the route resides in.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// 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).
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	MeshOwner *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The AWS IAM account ID of the resource owner. If the account ID is not your own,
                                                                                                                                                                                                  	// then it's the ID of the mesh owner or of another account that the mesh is shared
                                                                                                                                                                                                  	// with. For more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	ResourceOwner *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The name of the route.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	RouteName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The version of the resource. Resources are created at version 1, and this
                                                                                                                                                                                                  	// version is incremented each time that they're updated.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	Version *int64
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The virtual router that the route is associated with.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	VirtualRouterName *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                    An object that represents a route returned by a list operation.

                                                                                                                                                                                                    type RouteSpec

                                                                                                                                                                                                    type RouteSpec struct {
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// An object that represents the specification of a gRPC route.
                                                                                                                                                                                                    	GrpcRoute *GrpcRoute
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// An object that represents the specification of an HTTP/2 route.
                                                                                                                                                                                                    	Http2Route *HttpRoute
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// An object that represents the specification of an HTTP route.
                                                                                                                                                                                                    	HttpRoute *HttpRoute
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The priority for the route. Routes are matched based on the specified value,
                                                                                                                                                                                                    	// where 0 is the highest priority.
                                                                                                                                                                                                    	Priority *int32
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// An object that represents the specification of a TCP route.
                                                                                                                                                                                                    	TcpRoute *TcpRoute
                                                                                                                                                                                                    }

                                                                                                                                                                                                      An object that represents a route specification. Specify one route type.

                                                                                                                                                                                                      type RouteStatus

                                                                                                                                                                                                      type RouteStatus struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The current status for the route.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	Status RouteStatusCode
                                                                                                                                                                                                      }

                                                                                                                                                                                                        An object that represents the current status of a route.

                                                                                                                                                                                                        type RouteStatusCode

                                                                                                                                                                                                        type RouteStatusCode string
                                                                                                                                                                                                        const (
                                                                                                                                                                                                        	RouteStatusCodeActive   RouteStatusCode = "ACTIVE"
                                                                                                                                                                                                        	RouteStatusCodeInactive RouteStatusCode = "INACTIVE"
                                                                                                                                                                                                        	RouteStatusCodeDeleted  RouteStatusCode = "DELETED"
                                                                                                                                                                                                        )

                                                                                                                                                                                                          Enum values for RouteStatusCode

                                                                                                                                                                                                          func (RouteStatusCode) Values

                                                                                                                                                                                                          func (RouteStatusCode) Values() []RouteStatusCode

                                                                                                                                                                                                            Values returns all known values for RouteStatusCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                            type ServiceDiscovery

                                                                                                                                                                                                            type ServiceDiscovery interface {
                                                                                                                                                                                                            	// contains filtered or unexported methods
                                                                                                                                                                                                            }

                                                                                                                                                                                                              An object that represents the service discovery information for a virtual node.

                                                                                                                                                                                                              The following types satisfy this interface:

                                                                                                                                                                                                              ServiceDiscoveryMemberDns
                                                                                                                                                                                                              ServiceDiscoveryMemberAwsCloudMap
                                                                                                                                                                                                              
                                                                                                                                                                                                              Example (OutputUsage)
                                                                                                                                                                                                              Output:
                                                                                                                                                                                                              
                                                                                                                                                                                                              

                                                                                                                                                                                                              type ServiceDiscoveryMemberAwsCloudMap

                                                                                                                                                                                                              type ServiceDiscoveryMemberAwsCloudMap struct {
                                                                                                                                                                                                              	Value AwsCloudMapServiceDiscovery
                                                                                                                                                                                                              }

                                                                                                                                                                                                                Specifies any AWS Cloud Map information for the virtual node.

                                                                                                                                                                                                                type ServiceDiscoveryMemberDns

                                                                                                                                                                                                                type ServiceDiscoveryMemberDns struct {
                                                                                                                                                                                                                	Value DnsServiceDiscovery
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  Specifies the DNS information for the virtual node.

                                                                                                                                                                                                                  type ServiceUnavailableException

                                                                                                                                                                                                                  type ServiceUnavailableException struct {
                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    The request has failed due to a temporary failure of the service.

                                                                                                                                                                                                                    func (*ServiceUnavailableException) Error

                                                                                                                                                                                                                    func (*ServiceUnavailableException) ErrorCode

                                                                                                                                                                                                                    func (e *ServiceUnavailableException) ErrorCode() string

                                                                                                                                                                                                                    func (*ServiceUnavailableException) ErrorFault

                                                                                                                                                                                                                    func (*ServiceUnavailableException) ErrorMessage

                                                                                                                                                                                                                    func (e *ServiceUnavailableException) ErrorMessage() string

                                                                                                                                                                                                                    type TagRef

                                                                                                                                                                                                                    type TagRef struct {
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// One part of a key-value pair that make up a tag. A key is a general label that
                                                                                                                                                                                                                    	// acts like a category for more specific tag values.
                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                    	Key *string
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The optional part of a key-value pair that make up a tag. A value acts as a
                                                                                                                                                                                                                    	// descriptor within a tag category (key).
                                                                                                                                                                                                                    	Value *string
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      Optional metadata that you apply to a resource 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.

                                                                                                                                                                                                                      type TcpRetryPolicyEvent

                                                                                                                                                                                                                      type TcpRetryPolicyEvent string
                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                      	TcpRetryPolicyEventConnectionError TcpRetryPolicyEvent = "connection-error"
                                                                                                                                                                                                                      )

                                                                                                                                                                                                                        Enum values for TcpRetryPolicyEvent

                                                                                                                                                                                                                        func (TcpRetryPolicyEvent) Values

                                                                                                                                                                                                                          Values returns all known values for TcpRetryPolicyEvent. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                          type TcpRoute

                                                                                                                                                                                                                          type TcpRoute struct {
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The action to take if a match is determined.
                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                          	Action *TcpRouteAction
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// An object that represents types of timeouts.
                                                                                                                                                                                                                          	Timeout *TcpTimeout
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            An object that represents a TCP route type.

                                                                                                                                                                                                                            type TcpRouteAction

                                                                                                                                                                                                                            type TcpRouteAction struct {
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// An object that represents the targets that traffic is routed to when a request
                                                                                                                                                                                                                            	// matches the route.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                            	WeightedTargets []WeightedTarget
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              An object that represents the action to take if a match is determined.

                                                                                                                                                                                                                              type TcpTimeout

                                                                                                                                                                                                                              type TcpTimeout struct {
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// An object that represents a duration of time.
                                                                                                                                                                                                                              	Idle *Duration
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                An object that represents types of timeouts.

                                                                                                                                                                                                                                type TlsValidationContext

                                                                                                                                                                                                                                type TlsValidationContext struct {
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// A reference to an object that represents a TLS validation context trust.
                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                	Trust TlsValidationContextTrust
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  An object that represents a Transport Layer Security (TLS) validation context.

                                                                                                                                                                                                                                  type TlsValidationContextAcmTrust

                                                                                                                                                                                                                                  type TlsValidationContextAcmTrust struct {
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// One or more ACM Amazon Resource Name (ARN)s.
                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                  	CertificateAuthorityArns []string
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    An object that represents a TLS validation context trust for an AWS Certicate Manager (ACM) certificate.

                                                                                                                                                                                                                                    type TlsValidationContextFileTrust

                                                                                                                                                                                                                                    type TlsValidationContextFileTrust struct {
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The certificate trust chain for a certificate stored on the file system of the
                                                                                                                                                                                                                                    	// virtual node that the proxy is running on.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                    	CertificateChain *string
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      An object that represents a Transport Layer Security (TLS) validation context trust for a local file.

                                                                                                                                                                                                                                      type TlsValidationContextTrust

                                                                                                                                                                                                                                      type TlsValidationContextTrust interface {
                                                                                                                                                                                                                                      	// contains filtered or unexported methods
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        An object that represents a Transport Layer Security (TLS) validation context trust.

                                                                                                                                                                                                                                        The following types satisfy this interface:

                                                                                                                                                                                                                                        TlsValidationContextTrustMemberAcm
                                                                                                                                                                                                                                        TlsValidationContextTrustMemberFile
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        Example (OutputUsage)
                                                                                                                                                                                                                                        Output:
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                        type TlsValidationContextTrustMemberAcm

                                                                                                                                                                                                                                        type TlsValidationContextTrustMemberAcm struct {
                                                                                                                                                                                                                                        	Value TlsValidationContextAcmTrust
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          A reference to an object that represents a TLS validation context trust for an AWS Certicate Manager (ACM) certificate.

                                                                                                                                                                                                                                          type TlsValidationContextTrustMemberFile

                                                                                                                                                                                                                                          type TlsValidationContextTrustMemberFile struct {
                                                                                                                                                                                                                                          	Value TlsValidationContextFileTrust
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            An object that represents a TLS validation context trust for a local file.

                                                                                                                                                                                                                                            type TooManyRequestsException

                                                                                                                                                                                                                                            type TooManyRequestsException struct {
                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              The maximum request rate permitted by the App Mesh APIs has been exceeded for your account. For best results, use an increasing or variable sleep interval between requests.

                                                                                                                                                                                                                                              func (*TooManyRequestsException) Error

                                                                                                                                                                                                                                              func (e *TooManyRequestsException) Error() string

                                                                                                                                                                                                                                              func (*TooManyRequestsException) ErrorCode

                                                                                                                                                                                                                                              func (e *TooManyRequestsException) ErrorCode() string

                                                                                                                                                                                                                                              func (*TooManyRequestsException) ErrorFault

                                                                                                                                                                                                                                              func (e *TooManyRequestsException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                              func (*TooManyRequestsException) ErrorMessage

                                                                                                                                                                                                                                              func (e *TooManyRequestsException) ErrorMessage() string

                                                                                                                                                                                                                                              type TooManyTagsException

                                                                                                                                                                                                                                              type TooManyTagsException struct {
                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                The request exceeds the maximum allowed number of tags allowed per resource. The current limit is 50 user tags per resource. You must reduce the number of tags in the request. None of the tags in this request were applied.

                                                                                                                                                                                                                                                func (*TooManyTagsException) Error

                                                                                                                                                                                                                                                func (e *TooManyTagsException) Error() string

                                                                                                                                                                                                                                                func (*TooManyTagsException) ErrorCode

                                                                                                                                                                                                                                                func (e *TooManyTagsException) ErrorCode() string

                                                                                                                                                                                                                                                func (*TooManyTagsException) ErrorFault

                                                                                                                                                                                                                                                func (e *TooManyTagsException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                func (*TooManyTagsException) ErrorMessage

                                                                                                                                                                                                                                                func (e *TooManyTagsException) ErrorMessage() string

                                                                                                                                                                                                                                                type UnknownUnionMember

                                                                                                                                                                                                                                                type UnknownUnionMember struct {
                                                                                                                                                                                                                                                	Tag   string
                                                                                                                                                                                                                                                	Value []byte
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  UnknownUnionMember is returned when a union member is returned over the wire, but has an unknown tag.

                                                                                                                                                                                                                                                  type VirtualGatewayAccessLog

                                                                                                                                                                                                                                                  type VirtualGatewayAccessLog interface {
                                                                                                                                                                                                                                                  	// contains filtered or unexported methods
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    The access log configuration for a virtual gateway.

                                                                                                                                                                                                                                                    The following types satisfy this interface:

                                                                                                                                                                                                                                                    VirtualGatewayAccessLogMemberFile
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    Example (OutputUsage)
                                                                                                                                                                                                                                                    Output:
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                    type VirtualGatewayAccessLogMemberFile

                                                                                                                                                                                                                                                    type VirtualGatewayAccessLogMemberFile struct {
                                                                                                                                                                                                                                                    	Value VirtualGatewayFileAccessLog
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      The file object to send virtual gateway access logs to.

                                                                                                                                                                                                                                                      type VirtualGatewayBackendDefaults

                                                                                                                                                                                                                                                      type VirtualGatewayBackendDefaults struct {
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// A reference to an object that represents a client policy.
                                                                                                                                                                                                                                                      	ClientPolicy *VirtualGatewayClientPolicy
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        An object that represents the default properties for a backend.

                                                                                                                                                                                                                                                        type VirtualGatewayClientPolicy

                                                                                                                                                                                                                                                        type VirtualGatewayClientPolicy struct {
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// A reference to an object that represents a Transport Layer Security (TLS) client
                                                                                                                                                                                                                                                        	// policy.
                                                                                                                                                                                                                                                        	Tls *VirtualGatewayClientPolicyTls
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          An object that represents a client policy.

                                                                                                                                                                                                                                                          type VirtualGatewayClientPolicyTls

                                                                                                                                                                                                                                                          type VirtualGatewayClientPolicyTls struct {
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// A reference to an object that represents a TLS validation context.
                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                          	Validation *VirtualGatewayTlsValidationContext
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Whether the policy is enforced. The default is True, if a value isn't specified.
                                                                                                                                                                                                                                                          	Enforce *bool
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// One or more ports that the policy is enforced for.
                                                                                                                                                                                                                                                          	Ports []int32
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            An object that represents a Transport Layer Security (TLS) client policy.

                                                                                                                                                                                                                                                            type VirtualGatewayData

                                                                                                                                                                                                                                                            type VirtualGatewayData struct {
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The name of the service mesh that the virtual gateway resides in.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                            	MeshName *string
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// An object that represents metadata for a resource.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                            	Metadata *ResourceMetadata
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The specifications of the virtual gateway.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                            	Spec *VirtualGatewaySpec
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The current status of the virtual gateway.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                            	Status *VirtualGatewayStatus
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The name of the virtual gateway.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                            	VirtualGatewayName *string
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              An object that represents a virtual gateway returned by a describe operation.

                                                                                                                                                                                                                                                              type VirtualGatewayFileAccessLog

                                                                                                                                                                                                                                                              type VirtualGatewayFileAccessLog struct {
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The file path to write access logs to. You can use /dev/stdout to send access
                                                                                                                                                                                                                                                              	// logs to standard out and configure your Envoy container to use a log driver,
                                                                                                                                                                                                                                                              	// such as awslogs, to export the access logs to a log storage service such as
                                                                                                                                                                                                                                                              	// Amazon CloudWatch Logs. You can also specify a path in the Envoy container's
                                                                                                                                                                                                                                                              	// file system to write the files to disk.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                              	Path *string
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                An object that represents an access log file.

                                                                                                                                                                                                                                                                type VirtualGatewayHealthCheckPolicy

                                                                                                                                                                                                                                                                type VirtualGatewayHealthCheckPolicy struct {
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The number of consecutive successful health checks that must occur before
                                                                                                                                                                                                                                                                	// declaring the listener healthy.
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                	HealthyThreshold int32
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The time period in milliseconds between each health check execution.
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                	IntervalMillis *int64
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The protocol for the health check request. If you specify grpc, then your
                                                                                                                                                                                                                                                                	// service must conform to the GRPC Health Checking Protocol
                                                                                                                                                                                                                                                                	// (https://github.com/grpc/grpc/blob/master/doc/health-checking.md).
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                	Protocol VirtualGatewayPortProtocol
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The amount of time to wait when receiving a response from the health check, in
                                                                                                                                                                                                                                                                	// milliseconds.
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                	TimeoutMillis *int64
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The number of consecutive failed health checks that must occur before declaring
                                                                                                                                                                                                                                                                	// a virtual gateway unhealthy.
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                	UnhealthyThreshold int32
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The destination path for the health check request. This value is only used if
                                                                                                                                                                                                                                                                	// the specified protocol is HTTP or HTTP/2. For any other protocol, this value is
                                                                                                                                                                                                                                                                	// ignored.
                                                                                                                                                                                                                                                                	Path *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The destination port for the health check request. This port must match the port
                                                                                                                                                                                                                                                                	// defined in the PortMapping for the listener.
                                                                                                                                                                                                                                                                	Port int32
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  An object that represents the health check policy for a virtual gateway's listener.

                                                                                                                                                                                                                                                                  type VirtualGatewayListener

                                                                                                                                                                                                                                                                  type VirtualGatewayListener struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The port mapping information for the listener.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	PortMapping *VirtualGatewayPortMapping
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The health check information for the listener.
                                                                                                                                                                                                                                                                  	HealthCheck *VirtualGatewayHealthCheckPolicy
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// A reference to an object that represents the Transport Layer Security (TLS)
                                                                                                                                                                                                                                                                  	// properties for the listener.
                                                                                                                                                                                                                                                                  	Tls *VirtualGatewayListenerTls
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    An object that represents a listener for a virtual gateway.

                                                                                                                                                                                                                                                                    type VirtualGatewayListenerTls

                                                                                                                                                                                                                                                                    type VirtualGatewayListenerTls struct {
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// An object that represents a Transport Layer Security (TLS) certificate.
                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                    	Certificate VirtualGatewayListenerTlsCertificate
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// Specify one of the following modes.
                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                    	// * STRICT – Listener only accepts
                                                                                                                                                                                                                                                                    	// connections with TLS enabled.
                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                    	// * PERMISSIVE – Listener accepts connections with
                                                                                                                                                                                                                                                                    	// or without TLS enabled.
                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                    	// * DISABLED – Listener only accepts connections without
                                                                                                                                                                                                                                                                    	// TLS.
                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                    	Mode VirtualGatewayListenerTlsMode
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      An object that represents the Transport Layer Security (TLS) properties for a listener.

                                                                                                                                                                                                                                                                      type VirtualGatewayListenerTlsAcmCertificate

                                                                                                                                                                                                                                                                      type VirtualGatewayListenerTlsAcmCertificate struct {
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) for the certificate. The certificate must meet
                                                                                                                                                                                                                                                                      	// specific requirements and you must have proxy authorization enabled. For more
                                                                                                                                                                                                                                                                      	// information, see Transport Layer Security (TLS)
                                                                                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/tls.html#virtual-node-tls-prerequisites).
                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                      	CertificateArn *string
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        An object that represents an AWS Certicate Manager (ACM) certificate.

                                                                                                                                                                                                                                                                        type VirtualGatewayListenerTlsCertificate

                                                                                                                                                                                                                                                                        type VirtualGatewayListenerTlsCertificate interface {
                                                                                                                                                                                                                                                                        	// contains filtered or unexported methods
                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                          An object that represents a listener's Transport Layer Security (TLS) certificate.

                                                                                                                                                                                                                                                                          The following types satisfy this interface:

                                                                                                                                                                                                                                                                          VirtualGatewayListenerTlsCertificateMemberAcm
                                                                                                                                                                                                                                                                          VirtualGatewayListenerTlsCertificateMemberFile
                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                          Example (OutputUsage)
                                                                                                                                                                                                                                                                          Output:
                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                          type VirtualGatewayListenerTlsCertificateMemberAcm

                                                                                                                                                                                                                                                                          type VirtualGatewayListenerTlsCertificateMemberAcm struct {
                                                                                                                                                                                                                                                                          	Value VirtualGatewayListenerTlsAcmCertificate
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            A reference to an object that represents an AWS Certicate Manager (ACM) certificate.

                                                                                                                                                                                                                                                                            type VirtualGatewayListenerTlsCertificateMemberFile

                                                                                                                                                                                                                                                                            type VirtualGatewayListenerTlsCertificateMemberFile struct {
                                                                                                                                                                                                                                                                            	Value VirtualGatewayListenerTlsFileCertificate
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              A reference to an object that represents a local file certificate.

                                                                                                                                                                                                                                                                              type VirtualGatewayListenerTlsFileCertificate

                                                                                                                                                                                                                                                                              type VirtualGatewayListenerTlsFileCertificate struct {
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              	// The certificate chain for the certificate.
                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                              	CertificateChain *string
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              	// The private key for a certificate stored on the file system of the mesh endpoint
                                                                                                                                                                                                                                                                              	// that the proxy is running on.
                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                              	PrivateKey *string
                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                An object that represents a local file certificate. The certificate must meet specific requirements and you must have proxy authorization enabled. For more information, see Transport Layer Security (TLS) (https://docs.aws.amazon.com/app-mesh/latest/userguide/tls.html#virtual-node-tls-prerequisites).

                                                                                                                                                                                                                                                                                type VirtualGatewayListenerTlsMode

                                                                                                                                                                                                                                                                                type VirtualGatewayListenerTlsMode string
                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                	VirtualGatewayListenerTlsModeStrict     VirtualGatewayListenerTlsMode = "STRICT"
                                                                                                                                                                                                                                                                                	VirtualGatewayListenerTlsModePermissive VirtualGatewayListenerTlsMode = "PERMISSIVE"
                                                                                                                                                                                                                                                                                	VirtualGatewayListenerTlsModeDisabled   VirtualGatewayListenerTlsMode = "DISABLED"
                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                  Enum values for VirtualGatewayListenerTlsMode

                                                                                                                                                                                                                                                                                  func (VirtualGatewayListenerTlsMode) Values

                                                                                                                                                                                                                                                                                    Values returns all known values for VirtualGatewayListenerTlsMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                    type VirtualGatewayLogging

                                                                                                                                                                                                                                                                                    type VirtualGatewayLogging struct {
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                    	// The access log configuration.
                                                                                                                                                                                                                                                                                    	AccessLog VirtualGatewayAccessLog
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      An object that represents logging information.

                                                                                                                                                                                                                                                                                      type VirtualGatewayPortMapping

                                                                                                                                                                                                                                                                                      type VirtualGatewayPortMapping struct {
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// The port used for the port mapping. Specify one protocol.
                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                      	Port int32
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// The protocol used for the port mapping.
                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                      	Protocol VirtualGatewayPortProtocol
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        An object that represents a port mapping.

                                                                                                                                                                                                                                                                                        type VirtualGatewayPortProtocol

                                                                                                                                                                                                                                                                                        type VirtualGatewayPortProtocol string
                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                        	VirtualGatewayPortProtocolHttp  VirtualGatewayPortProtocol = "http"
                                                                                                                                                                                                                                                                                        	VirtualGatewayPortProtocolHttp2 VirtualGatewayPortProtocol = "http2"
                                                                                                                                                                                                                                                                                        	VirtualGatewayPortProtocolGrpc  VirtualGatewayPortProtocol = "grpc"
                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                          Enum values for VirtualGatewayPortProtocol

                                                                                                                                                                                                                                                                                          func (VirtualGatewayPortProtocol) Values

                                                                                                                                                                                                                                                                                            Values returns all known values for VirtualGatewayPortProtocol. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                            type VirtualGatewayRef

                                                                                                                                                                                                                                                                                            type VirtualGatewayRef struct {
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The full Amazon Resource Name (ARN) for the resource.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	Arn *string
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The Unix epoch timestamp in seconds for when the resource was created.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The Unix epoch timestamp in seconds for when the resource was last updated.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	LastUpdatedAt *time.Time
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The name of the service mesh that the resource resides in.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// 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).
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	MeshOwner *string
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The AWS IAM account ID of the resource owner. If the account ID is not your own,
                                                                                                                                                                                                                                                                                            	// then it's the ID of the mesh owner or of another account that the mesh is shared
                                                                                                                                                                                                                                                                                            	// with. For more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	ResourceOwner *string
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The version of the resource. Resources are created at version 1, and this
                                                                                                                                                                                                                                                                                            	// version is incremented each time that they're updated.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	Version *int64
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The name of the resource.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	VirtualGatewayName *string
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              An object that represents a virtual gateway returned by a list operation.

                                                                                                                                                                                                                                                                                              type VirtualGatewaySpec

                                                                                                                                                                                                                                                                                              type VirtualGatewaySpec struct {
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// The listeners that the mesh endpoint is expected to receive inbound traffic
                                                                                                                                                                                                                                                                                              	// from. You can specify one listener.
                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                              	Listeners []VirtualGatewayListener
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// A reference to an object that represents the defaults for backends.
                                                                                                                                                                                                                                                                                              	BackendDefaults *VirtualGatewayBackendDefaults
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// An object that represents logging information.
                                                                                                                                                                                                                                                                                              	Logging *VirtualGatewayLogging
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                An object that represents the specification of a service mesh resource.

                                                                                                                                                                                                                                                                                                type VirtualGatewayStatus

                                                                                                                                                                                                                                                                                                type VirtualGatewayStatus struct {
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// The current status.
                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                	Status VirtualGatewayStatusCode
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  An object that represents the status of the mesh resource.

                                                                                                                                                                                                                                                                                                  type VirtualGatewayStatusCode

                                                                                                                                                                                                                                                                                                  type VirtualGatewayStatusCode string
                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                  	VirtualGatewayStatusCodeActive   VirtualGatewayStatusCode = "ACTIVE"
                                                                                                                                                                                                                                                                                                  	VirtualGatewayStatusCodeInactive VirtualGatewayStatusCode = "INACTIVE"
                                                                                                                                                                                                                                                                                                  	VirtualGatewayStatusCodeDeleted  VirtualGatewayStatusCode = "DELETED"
                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                    Enum values for VirtualGatewayStatusCode

                                                                                                                                                                                                                                                                                                    func (VirtualGatewayStatusCode) Values

                                                                                                                                                                                                                                                                                                      Values returns all known values for VirtualGatewayStatusCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                      type VirtualGatewayTlsValidationContext

                                                                                                                                                                                                                                                                                                      type VirtualGatewayTlsValidationContext struct {
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// A reference to an object that represents a TLS validation context trust.
                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                      	Trust VirtualGatewayTlsValidationContextTrust
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        An object that represents a Transport Layer Security (TLS) validation context.

                                                                                                                                                                                                                                                                                                        type VirtualGatewayTlsValidationContextAcmTrust

                                                                                                                                                                                                                                                                                                        type VirtualGatewayTlsValidationContextAcmTrust struct {
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// One or more ACM Amazon Resource Name (ARN)s.
                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                        	CertificateAuthorityArns []string
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          An object that represents a TLS validation context trust for an AWS Certicate Manager (ACM) certificate.

                                                                                                                                                                                                                                                                                                          type VirtualGatewayTlsValidationContextFileTrust

                                                                                                                                                                                                                                                                                                          type VirtualGatewayTlsValidationContextFileTrust struct {
                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                          	// The certificate trust chain for a certificate stored on the file system of the
                                                                                                                                                                                                                                                                                                          	// virtual node that the proxy is running on.
                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                          	CertificateChain *string
                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                            An object that represents a Transport Layer Security (TLS) validation context trust for a local file.

                                                                                                                                                                                                                                                                                                            type VirtualGatewayTlsValidationContextTrust

                                                                                                                                                                                                                                                                                                            type VirtualGatewayTlsValidationContextTrust interface {
                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported methods
                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                              An object that represents a Transport Layer Security (TLS) validation context trust.

                                                                                                                                                                                                                                                                                                              The following types satisfy this interface:

                                                                                                                                                                                                                                                                                                              VirtualGatewayTlsValidationContextTrustMemberAcm
                                                                                                                                                                                                                                                                                                              VirtualGatewayTlsValidationContextTrustMemberFile
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              Example (OutputUsage)
                                                                                                                                                                                                                                                                                                              Output:
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                              type VirtualGatewayTlsValidationContextTrustMemberAcm

                                                                                                                                                                                                                                                                                                              type VirtualGatewayTlsValidationContextTrustMemberAcm struct {
                                                                                                                                                                                                                                                                                                              	Value VirtualGatewayTlsValidationContextAcmTrust
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                A reference to an object that represents a TLS validation context trust for an AWS Certicate Manager (ACM) certificate.

                                                                                                                                                                                                                                                                                                                type VirtualGatewayTlsValidationContextTrustMemberFile

                                                                                                                                                                                                                                                                                                                type VirtualGatewayTlsValidationContextTrustMemberFile struct {
                                                                                                                                                                                                                                                                                                                	Value VirtualGatewayTlsValidationContextFileTrust
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                  An object that represents a TLS validation context trust for a local file.

                                                                                                                                                                                                                                                                                                                  type VirtualNodeData

                                                                                                                                                                                                                                                                                                                  type VirtualNodeData struct {
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The name of the service mesh that the virtual node resides in.
                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                  	MeshName *string
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The associated metadata for the virtual node.
                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                  	Metadata *ResourceMetadata
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The specifications of the virtual node.
                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                  	Spec *VirtualNodeSpec
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The current status for the virtual node.
                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                  	Status *VirtualNodeStatus
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The name of the virtual node.
                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                  	VirtualNodeName *string
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                    An object that represents a virtual node returned by a describe operation.

                                                                                                                                                                                                                                                                                                                    type VirtualNodeRef

                                                                                                                                                                                                                                                                                                                    type VirtualNodeRef struct {
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The full Amazon Resource Name (ARN) for the virtual node.
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                    	Arn *string
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The Unix epoch timestamp in seconds for when the resource was created.
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                    	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The Unix epoch timestamp in seconds for when the resource was last updated.
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                    	LastUpdatedAt *time.Time
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The name of the service mesh that the virtual node resides in.
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// 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).
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                    	MeshOwner *string
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The AWS IAM account ID of the resource owner. If the account ID is not your own,
                                                                                                                                                                                                                                                                                                                    	// then it's the ID of the mesh owner or of another account that the mesh is shared
                                                                                                                                                                                                                                                                                                                    	// with. For more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                    	ResourceOwner *string
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The version of the resource. Resources are created at version 1, and this
                                                                                                                                                                                                                                                                                                                    	// version is incremented each time that they're updated.
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                    	Version *int64
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The name of the virtual node.
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                    	VirtualNodeName *string
                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                      An object that represents a virtual node returned by a list operation.

                                                                                                                                                                                                                                                                                                                      type VirtualNodeServiceProvider

                                                                                                                                                                                                                                                                                                                      type VirtualNodeServiceProvider struct {
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The name of the virtual node that is acting as a service provider.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                      	VirtualNodeName *string
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        An object that represents a virtual node service provider.

                                                                                                                                                                                                                                                                                                                        type VirtualNodeSpec

                                                                                                                                                                                                                                                                                                                        type VirtualNodeSpec struct {
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// A reference to an object that represents the defaults for backends.
                                                                                                                                                                                                                                                                                                                        	BackendDefaults *BackendDefaults
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The backends that the virtual node is expected to send outbound traffic to.
                                                                                                                                                                                                                                                                                                                        	Backends []Backend
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The listener that the virtual node is expected to receive inbound traffic from.
                                                                                                                                                                                                                                                                                                                        	// You can specify one listener.
                                                                                                                                                                                                                                                                                                                        	Listeners []Listener
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The inbound and outbound access logging information for the virtual node.
                                                                                                                                                                                                                                                                                                                        	Logging *Logging
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The service discovery information for the virtual node. If your virtual node
                                                                                                                                                                                                                                                                                                                        	// does not expect ingress traffic, you can omit this parameter. If you specify a
                                                                                                                                                                                                                                                                                                                        	// listener, then you must specify service discovery information.
                                                                                                                                                                                                                                                                                                                        	ServiceDiscovery ServiceDiscovery
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          An object that represents the specification of a virtual node.

                                                                                                                                                                                                                                                                                                                          type VirtualNodeStatus

                                                                                                                                                                                                                                                                                                                          type VirtualNodeStatus struct {
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          	// The current status of the virtual node.
                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                          	Status VirtualNodeStatusCode
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            An object that represents the current status of the virtual node.

                                                                                                                                                                                                                                                                                                                            type VirtualNodeStatusCode

                                                                                                                                                                                                                                                                                                                            type VirtualNodeStatusCode string
                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                            	VirtualNodeStatusCodeActive   VirtualNodeStatusCode = "ACTIVE"
                                                                                                                                                                                                                                                                                                                            	VirtualNodeStatusCodeInactive VirtualNodeStatusCode = "INACTIVE"
                                                                                                                                                                                                                                                                                                                            	VirtualNodeStatusCodeDeleted  VirtualNodeStatusCode = "DELETED"
                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                              Enum values for VirtualNodeStatusCode

                                                                                                                                                                                                                                                                                                                              func (VirtualNodeStatusCode) Values

                                                                                                                                                                                                                                                                                                                                Values returns all known values for VirtualNodeStatusCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                type VirtualRouterData

                                                                                                                                                                                                                                                                                                                                type VirtualRouterData struct {
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The name of the service mesh that the virtual router resides in.
                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                	MeshName *string
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The associated metadata for the virtual router.
                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                	Metadata *ResourceMetadata
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The specifications of the virtual router.
                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                	Spec *VirtualRouterSpec
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The current status of the virtual router.
                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                	Status *VirtualRouterStatus
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The name of the virtual router.
                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                	VirtualRouterName *string
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  An object that represents a virtual router returned by a describe operation.

                                                                                                                                                                                                                                                                                                                                  type VirtualRouterListener

                                                                                                                                                                                                                                                                                                                                  type VirtualRouterListener struct {
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// An object that represents a port mapping.
                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                  	PortMapping *PortMapping
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    An object that represents a virtual router listener.

                                                                                                                                                                                                                                                                                                                                    type VirtualRouterRef

                                                                                                                                                                                                                                                                                                                                    type VirtualRouterRef struct {
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The full Amazon Resource Name (ARN) for the virtual router.
                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                    	Arn *string
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The Unix epoch timestamp in seconds for when the resource was created.
                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                    	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The Unix epoch timestamp in seconds for when the resource was last updated.
                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                    	LastUpdatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The name of the service mesh that the virtual router resides in.
                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                    	// 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).
                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                    	MeshOwner *string
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The AWS IAM account ID of the resource owner. If the account ID is not your own,
                                                                                                                                                                                                                                                                                                                                    	// then it's the ID of the mesh owner or of another account that the mesh is shared
                                                                                                                                                                                                                                                                                                                                    	// with. For more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                    	ResourceOwner *string
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The version of the resource. Resources are created at version 1, and this
                                                                                                                                                                                                                                                                                                                                    	// version is incremented each time that they're updated.
                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                    	Version *int64
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The name of the virtual router.
                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                    	VirtualRouterName *string
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      An object that represents a virtual router returned by a list operation.

                                                                                                                                                                                                                                                                                                                                      type VirtualRouterServiceProvider

                                                                                                                                                                                                                                                                                                                                      type VirtualRouterServiceProvider struct {
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// The name of the virtual router that is acting as a service provider.
                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                      	VirtualRouterName *string
                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                        An object that represents a virtual node service provider.

                                                                                                                                                                                                                                                                                                                                        type VirtualRouterSpec

                                                                                                                                                                                                                                                                                                                                        type VirtualRouterSpec struct {
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The listeners that the virtual router is expected to receive inbound traffic
                                                                                                                                                                                                                                                                                                                                        	// from. You can specify one listener.
                                                                                                                                                                                                                                                                                                                                        	Listeners []VirtualRouterListener
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          An object that represents the specification of a virtual router.

                                                                                                                                                                                                                                                                                                                                          type VirtualRouterStatus

                                                                                                                                                                                                                                                                                                                                          type VirtualRouterStatus struct {
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The current status of the virtual router.
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                          	Status VirtualRouterStatusCode
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            An object that represents the status of a virtual router.

                                                                                                                                                                                                                                                                                                                                            type VirtualRouterStatusCode

                                                                                                                                                                                                                                                                                                                                            type VirtualRouterStatusCode string
                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                            	VirtualRouterStatusCodeActive   VirtualRouterStatusCode = "ACTIVE"
                                                                                                                                                                                                                                                                                                                                            	VirtualRouterStatusCodeInactive VirtualRouterStatusCode = "INACTIVE"
                                                                                                                                                                                                                                                                                                                                            	VirtualRouterStatusCodeDeleted  VirtualRouterStatusCode = "DELETED"
                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                              Enum values for VirtualRouterStatusCode

                                                                                                                                                                                                                                                                                                                                              func (VirtualRouterStatusCode) Values

                                                                                                                                                                                                                                                                                                                                                Values returns all known values for VirtualRouterStatusCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                type VirtualServiceBackend

                                                                                                                                                                                                                                                                                                                                                type VirtualServiceBackend struct {
                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                	// The name of the virtual service that is acting as a virtual node backend.
                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                	VirtualServiceName *string
                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                	// A reference to an object that represents the client policy for a backend.
                                                                                                                                                                                                                                                                                                                                                	ClientPolicy *ClientPolicy
                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                  An object that represents a virtual service backend for a virtual node.

                                                                                                                                                                                                                                                                                                                                                  type VirtualServiceData

                                                                                                                                                                                                                                                                                                                                                  type VirtualServiceData struct {
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The name of the service mesh that the virtual service resides in.
                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                  	MeshName *string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// An object that represents metadata for a resource.
                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                  	Metadata *ResourceMetadata
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The specifications of the virtual service.
                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                  	Spec *VirtualServiceSpec
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The current status of the virtual service.
                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                  	Status *VirtualServiceStatus
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The name of the virtual service.
                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                  	VirtualServiceName *string
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    An object that represents a virtual service returned by a describe operation.

                                                                                                                                                                                                                                                                                                                                                    type VirtualServiceProvider

                                                                                                                                                                                                                                                                                                                                                    type VirtualServiceProvider interface {
                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported methods
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                      An object that represents the provider for a virtual service.

                                                                                                                                                                                                                                                                                                                                                      The following types satisfy this interface:

                                                                                                                                                                                                                                                                                                                                                      VirtualServiceProviderMemberVirtualNode
                                                                                                                                                                                                                                                                                                                                                      VirtualServiceProviderMemberVirtualRouter
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      Example (OutputUsage)
                                                                                                                                                                                                                                                                                                                                                      Output:
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                      type VirtualServiceProviderMemberVirtualNode

                                                                                                                                                                                                                                                                                                                                                      type VirtualServiceProviderMemberVirtualNode struct {
                                                                                                                                                                                                                                                                                                                                                      	Value VirtualNodeServiceProvider
                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                        The virtual node associated with a virtual service.

                                                                                                                                                                                                                                                                                                                                                        type VirtualServiceProviderMemberVirtualRouter

                                                                                                                                                                                                                                                                                                                                                        type VirtualServiceProviderMemberVirtualRouter struct {
                                                                                                                                                                                                                                                                                                                                                        	Value VirtualRouterServiceProvider
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                          The virtual router associated with a virtual service.

                                                                                                                                                                                                                                                                                                                                                          type VirtualServiceRef

                                                                                                                                                                                                                                                                                                                                                          type VirtualServiceRef struct {
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The full Amazon Resource Name (ARN) for the virtual service.
                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                          	Arn *string
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The Unix epoch timestamp in seconds for when the resource was created.
                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                          	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The Unix epoch timestamp in seconds for when the resource was last updated.
                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                          	LastUpdatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The name of the service mesh that the virtual service resides in.
                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                          	// 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).
                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                          	MeshOwner *string
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The AWS IAM account ID of the resource owner. If the account ID is not your own,
                                                                                                                                                                                                                                                                                                                                                          	// then it's the ID of the mesh owner or of another account that the mesh is shared
                                                                                                                                                                                                                                                                                                                                                          	// with. For more information about mesh sharing, see Working with shared meshes
                                                                                                                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/app-mesh/latest/userguide/sharing.html).
                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                          	ResourceOwner *string
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The version of the resource. Resources are created at version 1, and this
                                                                                                                                                                                                                                                                                                                                                          	// version is incremented each time that they're updated.
                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                          	Version *int64
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The name of the virtual service.
                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                          	VirtualServiceName *string
                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                            An object that represents a virtual service returned by a list operation.

                                                                                                                                                                                                                                                                                                                                                            type VirtualServiceSpec

                                                                                                                                                                                                                                                                                                                                                            type VirtualServiceSpec struct {
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The App Mesh object that is acting as the provider for a virtual service. You
                                                                                                                                                                                                                                                                                                                                                            	// can specify a single virtual node or virtual router.
                                                                                                                                                                                                                                                                                                                                                            	Provider VirtualServiceProvider
                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                              An object that represents the specification of a virtual service.

                                                                                                                                                                                                                                                                                                                                                              type VirtualServiceStatus

                                                                                                                                                                                                                                                                                                                                                              type VirtualServiceStatus struct {
                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                              	// The current status of the virtual service.
                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                              	Status VirtualServiceStatusCode
                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                An object that represents the status of a virtual service.

                                                                                                                                                                                                                                                                                                                                                                type VirtualServiceStatusCode

                                                                                                                                                                                                                                                                                                                                                                type VirtualServiceStatusCode string
                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                	VirtualServiceStatusCodeActive   VirtualServiceStatusCode = "ACTIVE"
                                                                                                                                                                                                                                                                                                                                                                	VirtualServiceStatusCodeInactive VirtualServiceStatusCode = "INACTIVE"
                                                                                                                                                                                                                                                                                                                                                                	VirtualServiceStatusCodeDeleted  VirtualServiceStatusCode = "DELETED"
                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                  Enum values for VirtualServiceStatusCode

                                                                                                                                                                                                                                                                                                                                                                  func (VirtualServiceStatusCode) Values

                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for VirtualServiceStatusCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                    type WeightedTarget

                                                                                                                                                                                                                                                                                                                                                                    type WeightedTarget struct {
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The virtual node to associate with the weighted target.
                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                    	VirtualNode *string
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The relative weight of the weighted target.
                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                    	Weight int32
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      An object that represents a target and its relative weight. Traffic is distributed across targets according to their relative weight. For example, a weighted target with a relative weight of 50 receives five times as much traffic as one with a relative weight of 10. The total weight for all targets combined must be less than or equal to 100.