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

type AccessLogMemberFile struct {
	Value *FileAccessLog
}

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.
	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.
	Value *string
}

type AwsCloudMapServiceDiscovery struct {
	// The name of the AWS Cloud Map namespace to use.
	NamespaceName *string
	// The name of the AWS Cloud Map service to use.
	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
}

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

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

type BackendMemberVirtualService struct {
	Value *VirtualServiceBackend
}

type BadRequestException struct {
	Message *string
}

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

type ClientPolicyTls struct {
	// 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
	// A reference to an object that represents a TLS validation context.
	Validation *TlsValidationContext
}

type ConflictException struct {
	Message *string
}

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

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

type DurationUnit string

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

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.
	Type EgressFilterType
}

type EgressFilterType string

const (
	EgressFilterTypeAllow_all EgressFilterType = "ALLOW_ALL"
	EgressFilterTypeDrop_all  EgressFilterType = "DROP_ALL"
)

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.
	Path *string
}

type ForbiddenException struct {
	Message *string
}

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

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

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

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

type GatewayRouteStatusCode string

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

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

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

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

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

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

type GrpcRetryPolicy struct {
	// An object that represents a duration of time.
	PerRetryTimeout *Duration
	// The maximum number of retry attempts.
	MaxRetries *int64
	// 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
	// Specify at least one of the valid values.
	GrpcRetryEvents []GrpcRetryPolicyEvent
}

type GrpcRetryPolicyEvent string

const (
	GrpcRetryPolicyEventCancelled          GrpcRetryPolicyEvent = "cancelled"
	GrpcRetryPolicyEventDeadline_exceeded  GrpcRetryPolicyEvent = "deadline-exceeded"
	GrpcRetryPolicyEventInternal           GrpcRetryPolicyEvent = "internal"
	GrpcRetryPolicyEventResource_exhausted GrpcRetryPolicyEvent = "resource-exhausted"
	GrpcRetryPolicyEventUnavailable        GrpcRetryPolicyEvent = "unavailable"
)

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

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

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

type GrpcRouteMetadata struct {
	// The name of the route.
	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
}

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

type GrpcRouteMetadataMatchMethodMemberExact struct {
	Value string
}

type GrpcRouteMetadataMatchMethodMemberPrefix struct {
	Value string
}

type GrpcRouteMetadataMatchMethodMemberRange struct {
	Value *MatchRange
}

type GrpcRouteMetadataMatchMethodMemberRegex struct {
	Value string
}

type GrpcRouteMetadataMatchMethodMemberSuffix struct {
	Value string
}

type GrpcTimeout struct {
	// 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 an idle timeout. An idle timeout bounds the amount of
	// time that a connection may be idle. The default value is none.
	Idle *Duration
}

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

type HeaderMatchMethodMemberExact struct {
	Value string
}

type HeaderMatchMethodMemberPrefix struct {
	Value string
}

type HeaderMatchMethodMemberRange struct {
	Value *MatchRange
}

type HeaderMatchMethodMemberRegex struct {
	Value string
}

type HeaderMatchMethodMemberSuffix struct {
	Value string
}

type HealthCheckPolicy struct {
	// The amount of time to wait when receiving a response from the health check, in
	// milliseconds.
	TimeoutMillis *int64
	// The time period in milliseconds between each health check execution.
	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).
	Protocol PortProtocol
	// The destination port for the health check request. This port must match the port
	// defined in the PortMapping () for the listener.
	Port *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 number of consecutive successful health checks that must occur before
	// declaring listener healthy.
	HealthyThreshold *int32
	// The number of consecutive failed health checks that must occur before declaring
	// a virtual node unhealthy.
	UnhealthyThreshold *int32
}

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

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

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.
	Prefix *string
}

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

type HttpRetryPolicy struct {
	// An object that represents a duration of time.
	PerRetryTimeout *Duration
	// The maximum number of retry attempts.
	MaxRetries *int64
	// 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
}

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

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

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

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.
	Prefix *string
	// 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 client request headers to match on.
	Headers []*HttpRouteHeader
}

type HttpScheme string

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

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

type InternalServerErrorException struct {
	Message *string
}

type LimitExceededException struct {
	Message *string
}

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

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

type ListenerTimeoutMemberGrpc struct {
	Value *GrpcTimeout
}

type ListenerTimeoutMemberHttp struct {
	Value *HttpTimeout
}

type ListenerTimeoutMemberHttp2 struct {
	Value *HttpTimeout
}

type ListenerTimeoutMemberTcp struct {
	Value *TcpTimeout
}

type ListenerTls struct {
	// 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.
	Mode ListenerTlsMode
	// A reference to an object that represents a listener's TLS certificate.
	Certificate ListenerTlsCertificate
}

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).
	CertificateArn *string
}

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

type ListenerTlsCertificateMemberAcm struct {
	Value *ListenerTlsAcmCertificate
}

type ListenerTlsCertificateMemberFile struct {
	Value *ListenerTlsFileCertificate
}

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

type ListenerTlsMode string

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

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

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

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

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

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

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

type MeshStatusCode string

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

type NotFoundException struct {
	Message *string
}

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

type PortProtocol string

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

type ResourceInUseException struct {
	Message *string
}

type ResourceMetadata struct {
	// The full Amazon Resource Name (ARN) for the resource.
	Arn *string
	// The version of the resource. Resources are created at version 1, and this
	// version is incremented each time that they're updated.
	Version *int64
	// The unique identifier for the resource.
	Uid *string
	// The Unix epoch timestamp in seconds for when the resource was created.
	CreatedAt *time.Time
	// The Unix epoch timestamp in seconds for when the resource was last updated.
	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).
	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).
	ResourceOwner *string
}

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

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

type RouteSpec struct {
	// 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 an HTTP route.
	HttpRoute *HttpRoute
	// An object that represents the specification of a TCP route.
	TcpRoute *TcpRoute
	// An object that represents the specification of an HTTP/2 route.
	Http2Route *HttpRoute
	// An object that represents the specification of a gRPC route.
	GrpcRoute *GrpcRoute
}

type RouteStatus struct {
	// The current status for the route.
	Status RouteStatusCode
}

type RouteStatusCode string

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

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

type ServiceDiscoveryMemberAwsCloudMap struct {
	Value *AwsCloudMapServiceDiscovery
}

type ServiceDiscoveryMemberDns struct {
	Value *DnsServiceDiscovery
}

type ServiceUnavailableException struct {
	Message *string
}

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

type TcpRetryPolicyEvent string

const (
	TcpRetryPolicyEventConnection_error TcpRetryPolicyEvent = "connection-error"
)

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

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

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

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

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

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.
	CertificateChain *string
}

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

type TlsValidationContextTrustMemberAcm struct {
	Value *TlsValidationContextAcmTrust
}

type TlsValidationContextTrustMemberFile struct {
	Value *TlsValidationContextFileTrust
}

type TooManyRequestsException struct {
	Message *string
}

type TooManyTagsException struct {
	Message *string
}

type UnknownUnionMember struct {
	Tag   string
	Value []byte
}

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

type VirtualGatewayAccessLogMemberFile struct {
	Value *VirtualGatewayFileAccessLog
}

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

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

type VirtualGatewayClientPolicyTls struct {
	// 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
	// A reference to an object that represents a TLS validation context.
	Validation *VirtualGatewayTlsValidationContext
}

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

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.
	Path *string
}

type VirtualGatewayHealthCheckPolicy struct {
	// The amount of time to wait when receiving a response from the health check, in
	// milliseconds.
	TimeoutMillis *int64
	// The time period in milliseconds between each health check execution.
	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).
	Protocol VirtualGatewayPortProtocol
	// The destination port for the health check request. This port must match the port
	// defined in the PortMapping () for the listener.
	Port *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 number of consecutive successful health checks that must occur before
	// declaring the listener healthy.
	HealthyThreshold *int32
	// The number of consecutive failed health checks that must occur before declaring
	// a virtual gateway unhealthy.
	UnhealthyThreshold *int32
}

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

type VirtualGatewayListenerTls struct {
	// 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.
	Mode VirtualGatewayListenerTlsMode
	// An object that represents a Transport Layer Security (TLS) certificate.
	Certificate VirtualGatewayListenerTlsCertificate
}

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).
	CertificateArn *string
}

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

type VirtualGatewayListenerTlsCertificateMemberAcm struct {
	Value *VirtualGatewayListenerTlsAcmCertificate
}

type VirtualGatewayListenerTlsCertificateMemberFile struct {
	Value *VirtualGatewayListenerTlsFileCertificate
}

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

type VirtualGatewayListenerTlsMode string

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

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

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

type VirtualGatewayPortProtocol string

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

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

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

type VirtualGatewayStatus struct {
	// The current status.
	Status VirtualGatewayStatusCode
}

type VirtualGatewayStatusCode string

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

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

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

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.
	CertificateChain *string
}

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

type VirtualGatewayTlsValidationContextTrustMemberAcm struct {
	Value *VirtualGatewayTlsValidationContextAcmTrust
}

type VirtualGatewayTlsValidationContextTrustMemberFile struct {
	Value *VirtualGatewayTlsValidationContextFileTrust
}

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

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

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

type VirtualNodeSpec struct {
	// 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
	// The listener that the virtual node is expected to receive inbound traffic from.
	// You can specify one listener.
	Listeners []*Listener
	// The backends that the virtual node is expected to send outbound traffic to.
	Backends []Backend
	// A reference to an object that represents the defaults for backends.
	BackendDefaults *BackendDefaults
	// The inbound and outbound access logging information for the virtual node.
	Logging *Logging
}

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

type VirtualNodeStatusCode string

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

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

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

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

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

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

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

type VirtualRouterStatusCode string

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

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

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

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

type VirtualServiceProviderMemberVirtualNode struct {
	Value *VirtualNodeServiceProvider
}

type VirtualServiceProviderMemberVirtualRouter struct {
	Value *VirtualRouterServiceProvider
}

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

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
}

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

type VirtualServiceStatusCode string

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

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