Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccountAttribute

type AccountAttribute struct {

	// The name of the account attribute.
	AttributeName *string

	// The values for the account attribute.
	AttributeValues []AccountAttributeValue
}

    Describes an account attribute.

    type AccountAttributeName

    type AccountAttributeName string
    const (
    	AccountAttributeNameSupportedPlatforms AccountAttributeName = "supported-platforms"
    	AccountAttributeNameDefaultVpc         AccountAttributeName = "default-vpc"
    )

      Enum values for AccountAttributeName

      func (AccountAttributeName) Values

        Values returns all known values for AccountAttributeName. 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 AccountAttributeValue

        type AccountAttributeValue struct {
        
        	// The value of the attribute.
        	AttributeValue *string
        }

          Describes a value of an account attribute.

          type ActiveInstance

          type ActiveInstance struct {
          
          	// The health status of the instance. If the status of either the instance status
          	// check or the system status check is impaired, the health status of the instance
          	// is unhealthy. Otherwise, the health status is healthy.
          	InstanceHealth InstanceHealthStatus
          
          	// The ID of the instance.
          	InstanceId *string
          
          	// The instance type.
          	InstanceType *string
          
          	// The ID of the Spot Instance request.
          	SpotInstanceRequestId *string
          }

            Describes a running instance in a Spot Fleet.

            type ActivityStatus

            type ActivityStatus string
            const (
            	ActivityStatusError              ActivityStatus = "error"
            	ActivityStatusPendingFulfillment ActivityStatus = "pending_fulfillment"
            	ActivityStatusPendingTermination ActivityStatus = "pending_termination"
            	ActivityStatusFulfilled          ActivityStatus = "fulfilled"
            )

              Enum values for ActivityStatus

              func (ActivityStatus) Values

              func (ActivityStatus) Values() []ActivityStatus

                Values returns all known values for ActivityStatus. 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 AddPrefixListEntry

                type AddPrefixListEntry struct {
                
                	// The CIDR block.
                	//
                	// This member is required.
                	Cidr *string
                
                	// A description for the entry. Constraints: Up to 255 characters in length.
                	Description *string
                }

                  An entry for a prefix list.

                  type Address

                  type Address struct {
                  
                  	// The ID representing the allocation of the address for use with EC2-VPC.
                  	AllocationId *string
                  
                  	// The ID representing the association of the address with an instance in a VPC.
                  	AssociationId *string
                  
                  	// The carrier IP address associated. This option is only available for network
                  	// interfaces which reside in a subnet in a Wavelength Zone (for example an EC2
                  	// instance).
                  	CarrierIp *string
                  
                  	// The customer-owned IP address.
                  	CustomerOwnedIp *string
                  
                  	// The ID of the customer-owned address pool.
                  	CustomerOwnedIpv4Pool *string
                  
                  	// Indicates whether this Elastic IP address is for use with instances in
                  	// EC2-Classic (standard) or instances in a VPC (vpc).
                  	Domain DomainType
                  
                  	// The ID of the instance that the address is associated with (if any).
                  	InstanceId *string
                  
                  	// The name of the unique set of Availability Zones, Local Zones, or Wavelength
                  	// Zones from which AWS advertises IP addresses.
                  	NetworkBorderGroup *string
                  
                  	// The ID of the network interface.
                  	NetworkInterfaceId *string
                  
                  	// The ID of the AWS account that owns the network interface.
                  	NetworkInterfaceOwnerId *string
                  
                  	// The private IP address associated with the Elastic IP address.
                  	PrivateIpAddress *string
                  
                  	// The Elastic IP address.
                  	PublicIp *string
                  
                  	// The ID of an address pool.
                  	PublicIpv4Pool *string
                  
                  	// Any tags assigned to the Elastic IP address.
                  	Tags []Tag
                  }

                    Describes an Elastic IP address, or a carrier IP address.

                    type Affinity

                    type Affinity string
                    const (
                    	AffinityDefault Affinity = "default"
                    	AffinityHost    Affinity = "host"
                    )

                      Enum values for Affinity

                      func (Affinity) Values

                      func (Affinity) Values() []Affinity

                        Values returns all known values for Affinity. 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 AllocationState

                        type AllocationState string
                        const (
                        	AllocationStateAvailable                AllocationState = "available"
                        	AllocationStateUnderAssessment          AllocationState = "under-assessment"
                        	AllocationStatePermanentFailure         AllocationState = "permanent-failure"
                        	AllocationStateReleased                 AllocationState = "released"
                        	AllocationStateReleasedPermanentFailure AllocationState = "released-permanent-failure"
                        	AllocationStatePending                  AllocationState = "pending"
                        )

                          Enum values for AllocationState

                          func (AllocationState) Values

                          func (AllocationState) Values() []AllocationState

                            Values returns all known values for AllocationState. 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 AllocationStrategy

                            type AllocationStrategy string
                            const (
                            	AllocationStrategyLowestPrice       AllocationStrategy = "lowestPrice"
                            	AllocationStrategyDiversified       AllocationStrategy = "diversified"
                            	AllocationStrategyCapacityOptimized AllocationStrategy = "capacityOptimized"
                            )

                              Enum values for AllocationStrategy

                              func (AllocationStrategy) Values

                                Values returns all known values for AllocationStrategy. 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 AllowedPrincipal

                                type AllowedPrincipal struct {
                                
                                	// The Amazon Resource Name (ARN) of the principal.
                                	Principal *string
                                
                                	// The type of principal.
                                	PrincipalType PrincipalType
                                }

                                  Describes a principal.

                                  type AllowsMultipleInstanceTypes

                                  type AllowsMultipleInstanceTypes string
                                  const (
                                  	AllowsMultipleInstanceTypesOn  AllowsMultipleInstanceTypes = "on"
                                  	AllowsMultipleInstanceTypesOff AllowsMultipleInstanceTypes = "off"
                                  )

                                    Enum values for AllowsMultipleInstanceTypes

                                    func (AllowsMultipleInstanceTypes) Values

                                      Values returns all known values for AllowsMultipleInstanceTypes. 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 AlternatePathHint

                                      type AlternatePathHint struct {
                                      
                                      	// The Amazon Resource Name (ARN) of the component.
                                      	ComponentArn *string
                                      
                                      	// The ID of the component.
                                      	ComponentId *string
                                      }

                                        Describes an potential intermediate component of a feasible path.

                                        type AnalysisAclRule

                                        type AnalysisAclRule struct {
                                        
                                        	// The IPv4 address range, in CIDR notation.
                                        	Cidr *string
                                        
                                        	// Indicates whether the rule is an outbound rule.
                                        	Egress bool
                                        
                                        	// The range of ports.
                                        	PortRange *PortRange
                                        
                                        	// The protocol.
                                        	Protocol *string
                                        
                                        	// Indicates whether to allow or deny traffic that matches the rule.
                                        	RuleAction *string
                                        
                                        	// The rule number.
                                        	RuleNumber int32
                                        }

                                          Describes a network access control (ACL) rule.

                                          type AnalysisComponent

                                          type AnalysisComponent struct {
                                          
                                          	// The Amazon Resource Name (ARN) of the component.
                                          	Arn *string
                                          
                                          	// The ID of the component.
                                          	Id *string
                                          }

                                            Describes a path component.

                                            type AnalysisLoadBalancerListener

                                            type AnalysisLoadBalancerListener struct {
                                            
                                            	// [Classic Load Balancers] The back-end port for the listener.
                                            	InstancePort int32
                                            
                                            	// The port on which the load balancer is listening.
                                            	LoadBalancerPort int32
                                            }

                                              Describes a load balancer listener.

                                              type AnalysisLoadBalancerTarget

                                              type AnalysisLoadBalancerTarget struct {
                                              
                                              	// The IP address.
                                              	Address *string
                                              
                                              	// The Availability Zone.
                                              	AvailabilityZone *string
                                              
                                              	// Information about the instance.
                                              	Instance *AnalysisComponent
                                              
                                              	// The port on which the target is listening.
                                              	Port int32
                                              }

                                                Describes a load balancer target.

                                                type AnalysisPacketHeader

                                                type AnalysisPacketHeader struct {
                                                
                                                	// The destination addresses.
                                                	DestinationAddresses []string
                                                
                                                	// The destination port ranges.
                                                	DestinationPortRanges []PortRange
                                                
                                                	// The protocol.
                                                	Protocol *string
                                                
                                                	// The source addresses.
                                                	SourceAddresses []string
                                                
                                                	// The source port ranges.
                                                	SourcePortRanges []PortRange
                                                }

                                                  Describes a header. Reflects any changes made by a component as traffic passes through. The fields of an inbound header are null except for the first component of a path.

                                                  type AnalysisRouteTableRoute

                                                  type AnalysisRouteTableRoute struct {
                                                  
                                                  	// The destination IPv4 address, in CIDR notation.
                                                  	DestinationCidr *string
                                                  
                                                  	// The prefix of the AWS service.
                                                  	DestinationPrefixListId *string
                                                  
                                                  	// The ID of an egress-only internet gateway.
                                                  	EgressOnlyInternetGatewayId *string
                                                  
                                                  	// The ID of the gateway, such as an internet gateway or virtual private gateway.
                                                  	GatewayId *string
                                                  
                                                  	// The ID of the instance, such as a NAT instance.
                                                  	InstanceId *string
                                                  
                                                  	// The ID of a NAT gateway.
                                                  	NatGatewayId *string
                                                  
                                                  	// The ID of a network interface.
                                                  	NetworkInterfaceId *string
                                                  
                                                  	// Describes how the route was created. The following are possible values:
                                                  	//
                                                  	// *
                                                  	// CreateRouteTable - The route was automatically created when the route table was
                                                  	// created.
                                                  	//
                                                  	// * CreateRoute - The route was manually added to the route table.
                                                  	//
                                                  	// *
                                                  	// EnableVgwRoutePropagation - The route was propagated by route propagation.
                                                  	Origin *string
                                                  
                                                  	// The ID of a transit gateway.
                                                  	TransitGatewayId *string
                                                  
                                                  	// The ID of a VPC peering connection.
                                                  	VpcPeeringConnectionId *string
                                                  }

                                                    Describes a route table route.

                                                    type AnalysisSecurityGroupRule

                                                    type AnalysisSecurityGroupRule struct {
                                                    
                                                    	// The IPv4 address range, in CIDR notation.
                                                    	Cidr *string
                                                    
                                                    	// The direction. The following are possible values:
                                                    	//
                                                    	// * egress
                                                    	//
                                                    	// * ingress
                                                    	Direction *string
                                                    
                                                    	// The port range.
                                                    	PortRange *PortRange
                                                    
                                                    	// The prefix list ID.
                                                    	PrefixListId *string
                                                    
                                                    	// The protocol name.
                                                    	Protocol *string
                                                    
                                                    	// The security group ID.
                                                    	SecurityGroupId *string
                                                    }

                                                      Describes a security group rule.

                                                      type AnalysisStatus

                                                      type AnalysisStatus string
                                                      const (
                                                      	AnalysisStatusRunning   AnalysisStatus = "running"
                                                      	AnalysisStatusSucceeded AnalysisStatus = "succeeded"
                                                      	AnalysisStatusFailed    AnalysisStatus = "failed"
                                                      )

                                                        Enum values for AnalysisStatus

                                                        func (AnalysisStatus) Values

                                                        func (AnalysisStatus) Values() []AnalysisStatus

                                                          Values returns all known values for AnalysisStatus. 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 ApplianceModeSupportValue

                                                          type ApplianceModeSupportValue string
                                                          const (
                                                          	ApplianceModeSupportValueEnable  ApplianceModeSupportValue = "enable"
                                                          	ApplianceModeSupportValueDisable ApplianceModeSupportValue = "disable"
                                                          )

                                                            Enum values for ApplianceModeSupportValue

                                                            func (ApplianceModeSupportValue) Values

                                                              Values returns all known values for ApplianceModeSupportValue. 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 ArchitectureType

                                                              type ArchitectureType string
                                                              const (
                                                              	ArchitectureTypeI386  ArchitectureType = "i386"
                                                              	ArchitectureTypeX8664 ArchitectureType = "x86_64"
                                                              	ArchitectureTypeArm64 ArchitectureType = "arm64"
                                                              )

                                                                Enum values for ArchitectureType

                                                                func (ArchitectureType) Values

                                                                  Values returns all known values for ArchitectureType. 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 ArchitectureValues

                                                                  type ArchitectureValues string
                                                                  const (
                                                                  	ArchitectureValuesI386  ArchitectureValues = "i386"
                                                                  	ArchitectureValuesX8664 ArchitectureValues = "x86_64"
                                                                  	ArchitectureValuesArm64 ArchitectureValues = "arm64"
                                                                  )

                                                                    Enum values for ArchitectureValues

                                                                    func (ArchitectureValues) Values

                                                                      Values returns all known values for ArchitectureValues. 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 AssignedPrivateIpAddress

                                                                      type AssignedPrivateIpAddress struct {
                                                                      
                                                                      	// The private IP address assigned to the network interface.
                                                                      	PrivateIpAddress *string
                                                                      }

                                                                        Describes the private IP addresses assigned to a network interface.

                                                                        type AssociatedNetworkType

                                                                        type AssociatedNetworkType string
                                                                        const (
                                                                        	AssociatedNetworkTypeVpc AssociatedNetworkType = "vpc"
                                                                        )

                                                                          Enum values for AssociatedNetworkType

                                                                          func (AssociatedNetworkType) Values

                                                                            Values returns all known values for AssociatedNetworkType. 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 AssociatedRole

                                                                            type AssociatedRole struct {
                                                                            
                                                                            	// The ARN of the associated IAM role.
                                                                            	AssociatedRoleArn *string
                                                                            
                                                                            	// The name of the Amazon S3 bucket in which the Amazon S3 object is stored.
                                                                            	CertificateS3BucketName *string
                                                                            
                                                                            	// The key of the Amazon S3 object ey where the certificate, certificate chain, and
                                                                            	// encrypted private key bundle is stored. The object key is formated as follows:
                                                                            	// certificate_arn/role_arn.
                                                                            	CertificateS3ObjectKey *string
                                                                            
                                                                            	// The ID of the KMS customer master key (CMK) used to encrypt the private key.
                                                                            	EncryptionKmsKeyId *string
                                                                            }

                                                                              Information about the associated IAM roles.

                                                                              type AssociatedTargetNetwork

                                                                              type AssociatedTargetNetwork struct {
                                                                              
                                                                              	// The ID of the subnet.
                                                                              	NetworkId *string
                                                                              
                                                                              	// The target network type.
                                                                              	NetworkType AssociatedNetworkType
                                                                              }

                                                                                Describes a target network that is associated with a Client VPN endpoint. A target network is a subnet in a VPC.

                                                                                type AssociationStatus

                                                                                type AssociationStatus struct {
                                                                                
                                                                                	// The state of the target network association.
                                                                                	Code AssociationStatusCode
                                                                                
                                                                                	// A message about the status of the target network association, if applicable.
                                                                                	Message *string
                                                                                }

                                                                                  Describes the state of a target network association.

                                                                                  type AssociationStatusCode

                                                                                  type AssociationStatusCode string
                                                                                  const (
                                                                                  	AssociationStatusCodeAssociating       AssociationStatusCode = "associating"
                                                                                  	AssociationStatusCodeAssociated        AssociationStatusCode = "associated"
                                                                                  	AssociationStatusCodeAssociationFailed AssociationStatusCode = "association-failed"
                                                                                  	AssociationStatusCodeDisassociating    AssociationStatusCode = "disassociating"
                                                                                  	AssociationStatusCodeDisassociated     AssociationStatusCode = "disassociated"
                                                                                  )

                                                                                    Enum values for AssociationStatusCode

                                                                                    func (AssociationStatusCode) Values

                                                                                      Values returns all known values for AssociationStatusCode. 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 AttachmentStatus

                                                                                      type AttachmentStatus string
                                                                                      const (
                                                                                      	AttachmentStatusAttaching AttachmentStatus = "attaching"
                                                                                      	AttachmentStatusAttached  AttachmentStatus = "attached"
                                                                                      	AttachmentStatusDetaching AttachmentStatus = "detaching"
                                                                                      	AttachmentStatusDetached  AttachmentStatus = "detached"
                                                                                      )

                                                                                        Enum values for AttachmentStatus

                                                                                        func (AttachmentStatus) Values

                                                                                          Values returns all known values for AttachmentStatus. 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 AttributeBooleanValue

                                                                                          type AttributeBooleanValue struct {
                                                                                          
                                                                                          	// The attribute value. The valid values are true or false.
                                                                                          	Value bool
                                                                                          }

                                                                                            Describes a value for a resource attribute that is a Boolean value.

                                                                                            type AttributeValue

                                                                                            type AttributeValue struct {
                                                                                            
                                                                                            	// The attribute value. The value is case-sensitive.
                                                                                            	Value *string
                                                                                            }

                                                                                              Describes a value for a resource attribute that is a String.

                                                                                              type AuthorizationRule

                                                                                              type AuthorizationRule struct {
                                                                                              
                                                                                              	// Indicates whether the authorization rule grants access to all clients.
                                                                                              	AccessAll bool
                                                                                              
                                                                                              	// The ID of the Client VPN endpoint with which the authorization rule is
                                                                                              	// associated.
                                                                                              	ClientVpnEndpointId *string
                                                                                              
                                                                                              	// A brief description of the authorization rule.
                                                                                              	Description *string
                                                                                              
                                                                                              	// The IPv4 address range, in CIDR notation, of the network to which the
                                                                                              	// authorization rule applies.
                                                                                              	DestinationCidr *string
                                                                                              
                                                                                              	// The ID of the Active Directory group to which the authorization rule grants
                                                                                              	// access.
                                                                                              	GroupId *string
                                                                                              
                                                                                              	// The current state of the authorization rule.
                                                                                              	Status *ClientVpnAuthorizationRuleStatus
                                                                                              }

                                                                                                Information about an authorization rule.

                                                                                                type AutoAcceptSharedAssociationsValue

                                                                                                type AutoAcceptSharedAssociationsValue string
                                                                                                const (
                                                                                                	AutoAcceptSharedAssociationsValueEnable  AutoAcceptSharedAssociationsValue = "enable"
                                                                                                	AutoAcceptSharedAssociationsValueDisable AutoAcceptSharedAssociationsValue = "disable"
                                                                                                )

                                                                                                  Enum values for AutoAcceptSharedAssociationsValue

                                                                                                  func (AutoAcceptSharedAssociationsValue) Values

                                                                                                    Values returns all known values for AutoAcceptSharedAssociationsValue. 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 AutoAcceptSharedAttachmentsValue

                                                                                                    type AutoAcceptSharedAttachmentsValue string
                                                                                                    const (
                                                                                                    	AutoAcceptSharedAttachmentsValueEnable  AutoAcceptSharedAttachmentsValue = "enable"
                                                                                                    	AutoAcceptSharedAttachmentsValueDisable AutoAcceptSharedAttachmentsValue = "disable"
                                                                                                    )

                                                                                                      Enum values for AutoAcceptSharedAttachmentsValue

                                                                                                      func (AutoAcceptSharedAttachmentsValue) Values

                                                                                                        Values returns all known values for AutoAcceptSharedAttachmentsValue. 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 AutoPlacement

                                                                                                        type AutoPlacement string
                                                                                                        const (
                                                                                                        	AutoPlacementOn  AutoPlacement = "on"
                                                                                                        	AutoPlacementOff AutoPlacement = "off"
                                                                                                        )

                                                                                                          Enum values for AutoPlacement

                                                                                                          func (AutoPlacement) Values

                                                                                                          func (AutoPlacement) Values() []AutoPlacement

                                                                                                            Values returns all known values for AutoPlacement. 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 AvailabilityZone

                                                                                                            type AvailabilityZone struct {
                                                                                                            
                                                                                                            	// For Availability Zones, this parameter has the same value as the Region name.
                                                                                                            	// For Local Zones, the name of the associated group, for example us-west-2-lax-1.
                                                                                                            	// For Wavelength Zones, the name of the associated group, for example
                                                                                                            	// us-east-1-wl1-bos-wlz-1.
                                                                                                            	GroupName *string
                                                                                                            
                                                                                                            	// Any messages about the Availability Zone, Local Zone, or Wavelength Zone.
                                                                                                            	Messages []AvailabilityZoneMessage
                                                                                                            
                                                                                                            	// The name of the network border group.
                                                                                                            	NetworkBorderGroup *string
                                                                                                            
                                                                                                            	// For Availability Zones, this parameter always has the value of
                                                                                                            	// opt-in-not-required. For Local Zones and Wavelength Zones, this parameter is the
                                                                                                            	// opt-in status. The possible values are opted-in, and not-opted-in.
                                                                                                            	OptInStatus AvailabilityZoneOptInStatus
                                                                                                            
                                                                                                            	// The ID of the zone that handles some of the Local Zone or Wavelength Zone
                                                                                                            	// control plane operations, such as API calls.
                                                                                                            	ParentZoneId *string
                                                                                                            
                                                                                                            	// The name of the zone that handles some of the Local Zone or Wavelength Zone
                                                                                                            	// control plane operations, such as API calls.
                                                                                                            	ParentZoneName *string
                                                                                                            
                                                                                                            	// The name of the Region.
                                                                                                            	RegionName *string
                                                                                                            
                                                                                                            	// The state of the Availability Zone, Local Zone, or Wavelength Zone.
                                                                                                            	State AvailabilityZoneState
                                                                                                            
                                                                                                            	// The ID of the Availability Zone, Local Zone, or Wavelength Zone.
                                                                                                            	ZoneId *string
                                                                                                            
                                                                                                            	// The name of the Availability Zone, Local Zone, or Wavelength Zone.
                                                                                                            	ZoneName *string
                                                                                                            
                                                                                                            	// The type of zone. The valid values are availability-zone, local-zone, and
                                                                                                            	// wavelength-zone.
                                                                                                            	ZoneType *string
                                                                                                            }

                                                                                                              Describes Availability Zones, Local Zones, and Wavelength Zones.

                                                                                                              type AvailabilityZoneMessage

                                                                                                              type AvailabilityZoneMessage struct {
                                                                                                              
                                                                                                              	// The message about the Availability Zone, Local Zone, or Wavelength Zone.
                                                                                                              	Message *string
                                                                                                              }

                                                                                                                Describes a message about an Availability Zone, Local Zone, or Wavelength Zone.

                                                                                                                type AvailabilityZoneOptInStatus

                                                                                                                type AvailabilityZoneOptInStatus string
                                                                                                                const (
                                                                                                                	AvailabilityZoneOptInStatusOptInNotRequired AvailabilityZoneOptInStatus = "opt-in-not-required"
                                                                                                                	AvailabilityZoneOptInStatusOptedIn          AvailabilityZoneOptInStatus = "opted-in"
                                                                                                                	AvailabilityZoneOptInStatusNotOptedIn       AvailabilityZoneOptInStatus = "not-opted-in"
                                                                                                                )

                                                                                                                  Enum values for AvailabilityZoneOptInStatus

                                                                                                                  func (AvailabilityZoneOptInStatus) Values

                                                                                                                    Values returns all known values for AvailabilityZoneOptInStatus. 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 AvailabilityZoneState

                                                                                                                    type AvailabilityZoneState string
                                                                                                                    const (
                                                                                                                    	AvailabilityZoneStateAvailable   AvailabilityZoneState = "available"
                                                                                                                    	AvailabilityZoneStateInformation AvailabilityZoneState = "information"
                                                                                                                    	AvailabilityZoneStateImpaired    AvailabilityZoneState = "impaired"
                                                                                                                    	AvailabilityZoneStateUnavailable AvailabilityZoneState = "unavailable"
                                                                                                                    )

                                                                                                                      Enum values for AvailabilityZoneState

                                                                                                                      func (AvailabilityZoneState) Values

                                                                                                                        Values returns all known values for AvailabilityZoneState. 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 AvailableCapacity

                                                                                                                        type AvailableCapacity struct {
                                                                                                                        
                                                                                                                        	// The number of instances that can be launched onto the Dedicated Host depending
                                                                                                                        	// on the host's available capacity. For Dedicated Hosts that support multiple
                                                                                                                        	// instance types, this parameter represents the number of instances for each
                                                                                                                        	// instance size that is supported on the host.
                                                                                                                        	AvailableInstanceCapacity []InstanceCapacity
                                                                                                                        
                                                                                                                        	// The number of vCPUs available for launching instances onto the Dedicated Host.
                                                                                                                        	AvailableVCpus int32
                                                                                                                        }

                                                                                                                          The capacity information for instances that can be launched onto the Dedicated Host.

                                                                                                                          type BatchState

                                                                                                                          type BatchState string
                                                                                                                          const (
                                                                                                                          	BatchStateSubmitted                     BatchState = "submitted"
                                                                                                                          	BatchStateActive                        BatchState = "active"
                                                                                                                          	BatchStateCancelled                     BatchState = "cancelled"
                                                                                                                          	BatchStateFailed                        BatchState = "failed"
                                                                                                                          	BatchStateCancelledRunning              BatchState = "cancelled_running"
                                                                                                                          	BatchStateCancelledTerminatingInstances BatchState = "cancelled_terminating"
                                                                                                                          	BatchStateModifying                     BatchState = "modifying"
                                                                                                                          )

                                                                                                                            Enum values for BatchState

                                                                                                                            func (BatchState) Values

                                                                                                                            func (BatchState) Values() []BatchState

                                                                                                                              Values returns all known values for BatchState. 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 BgpStatus

                                                                                                                              type BgpStatus string
                                                                                                                              const (
                                                                                                                              	BgpStatusUp   BgpStatus = "up"
                                                                                                                              	BgpStatusDown BgpStatus = "down"
                                                                                                                              )

                                                                                                                                Enum values for BgpStatus

                                                                                                                                func (BgpStatus) Values

                                                                                                                                func (BgpStatus) Values() []BgpStatus

                                                                                                                                  Values returns all known values for BgpStatus. 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 BlobAttributeValue

                                                                                                                                  type BlobAttributeValue struct {
                                                                                                                                  	Value []byte
                                                                                                                                  }

                                                                                                                                  type BlockDeviceMapping

                                                                                                                                  type BlockDeviceMapping struct {
                                                                                                                                  
                                                                                                                                  	// The device name (for example, /dev/sdh or xvdh).
                                                                                                                                  	DeviceName *string
                                                                                                                                  
                                                                                                                                  	// Parameters used to automatically set up EBS volumes when the instance is
                                                                                                                                  	// launched.
                                                                                                                                  	Ebs *EbsBlockDevice
                                                                                                                                  
                                                                                                                                  	// To omit the device from the block device mapping, specify an empty string.
                                                                                                                                  	NoDevice *string
                                                                                                                                  
                                                                                                                                  	// The virtual device name (ephemeralN). Instance store volumes are numbered
                                                                                                                                  	// starting from 0. An instance type with 2 available instance store volumes can
                                                                                                                                  	// specify mappings for ephemeral0 and ephemeral1. The number of available instance
                                                                                                                                  	// store volumes depends on the instance type. After you connect to the instance,
                                                                                                                                  	// you must mount the volume. NVMe instance store volumes are automatically
                                                                                                                                  	// enumerated and assigned a device name. Including them in your block device
                                                                                                                                  	// mapping has no effect. Constraints: For M3 instances, you must specify instance
                                                                                                                                  	// store volumes in the block device mapping for the instance. When you launch an
                                                                                                                                  	// M3 instance, we ignore any instance store volumes specified in the block device
                                                                                                                                  	// mapping for the AMI.
                                                                                                                                  	VirtualName *string
                                                                                                                                  }

                                                                                                                                    Describes a block device mapping.

                                                                                                                                    type BundleTask

                                                                                                                                    type BundleTask struct {
                                                                                                                                    
                                                                                                                                    	// The ID of the bundle task.
                                                                                                                                    	BundleId *string
                                                                                                                                    
                                                                                                                                    	// If the task fails, a description of the error.
                                                                                                                                    	BundleTaskError *BundleTaskError
                                                                                                                                    
                                                                                                                                    	// The ID of the instance associated with this bundle task.
                                                                                                                                    	InstanceId *string
                                                                                                                                    
                                                                                                                                    	// The level of task completion, as a percent (for example, 20%).
                                                                                                                                    	Progress *string
                                                                                                                                    
                                                                                                                                    	// The time this task started.
                                                                                                                                    	StartTime *time.Time
                                                                                                                                    
                                                                                                                                    	// The state of the task.
                                                                                                                                    	State BundleTaskState
                                                                                                                                    
                                                                                                                                    	// The Amazon S3 storage locations.
                                                                                                                                    	Storage *Storage
                                                                                                                                    
                                                                                                                                    	// The time of the most recent update for the task.
                                                                                                                                    	UpdateTime *time.Time
                                                                                                                                    }

                                                                                                                                      Describes a bundle task.

                                                                                                                                      type BundleTaskError

                                                                                                                                      type BundleTaskError struct {
                                                                                                                                      
                                                                                                                                      	// The error code.
                                                                                                                                      	Code *string
                                                                                                                                      
                                                                                                                                      	// The error message.
                                                                                                                                      	Message *string
                                                                                                                                      }

                                                                                                                                        Describes an error for BundleInstance.

                                                                                                                                        type BundleTaskState

                                                                                                                                        type BundleTaskState string
                                                                                                                                        const (
                                                                                                                                        	BundleTaskStatePending            BundleTaskState = "pending"
                                                                                                                                        	BundleTaskStateWaitingForShutdown BundleTaskState = "waiting-for-shutdown"
                                                                                                                                        	BundleTaskStateBundling           BundleTaskState = "bundling"
                                                                                                                                        	BundleTaskStateStoring            BundleTaskState = "storing"
                                                                                                                                        	BundleTaskStateCancelling         BundleTaskState = "cancelling"
                                                                                                                                        	BundleTaskStateComplete           BundleTaskState = "complete"
                                                                                                                                        	BundleTaskStateFailed             BundleTaskState = "failed"
                                                                                                                                        )

                                                                                                                                          Enum values for BundleTaskState

                                                                                                                                          func (BundleTaskState) Values

                                                                                                                                          func (BundleTaskState) Values() []BundleTaskState

                                                                                                                                            Values returns all known values for BundleTaskState. 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 ByoipCidr

                                                                                                                                            type ByoipCidr struct {
                                                                                                                                            
                                                                                                                                            	// The address range, in CIDR notation.
                                                                                                                                            	Cidr *string
                                                                                                                                            
                                                                                                                                            	// The description of the address range.
                                                                                                                                            	Description *string
                                                                                                                                            
                                                                                                                                            	// The state of the address pool.
                                                                                                                                            	State ByoipCidrState
                                                                                                                                            
                                                                                                                                            	// Upon success, contains the ID of the address pool. Otherwise, contains an error
                                                                                                                                            	// message.
                                                                                                                                            	StatusMessage *string
                                                                                                                                            }

                                                                                                                                              Information about an address range that is provisioned for use with your AWS resources through bring your own IP addresses (BYOIP).

                                                                                                                                              type ByoipCidrState

                                                                                                                                              type ByoipCidrState string
                                                                                                                                              const (
                                                                                                                                              	ByoipCidrStateAdvertised                         ByoipCidrState = "advertised"
                                                                                                                                              	ByoipCidrStateDeprovisioned                      ByoipCidrState = "deprovisioned"
                                                                                                                                              	ByoipCidrStateFailedDeprovision                  ByoipCidrState = "failed-deprovision"
                                                                                                                                              	ByoipCidrStateFailedProvision                    ByoipCidrState = "failed-provision"
                                                                                                                                              	ByoipCidrStatePendingDeprovision                 ByoipCidrState = "pending-deprovision"
                                                                                                                                              	ByoipCidrStatePendingProvision                   ByoipCidrState = "pending-provision"
                                                                                                                                              	ByoipCidrStateProvisioned                        ByoipCidrState = "provisioned"
                                                                                                                                              	ByoipCidrStateProvisionedNotPubliclyAdvertisable ByoipCidrState = "provisioned-not-publicly-advertisable"
                                                                                                                                              )

                                                                                                                                                Enum values for ByoipCidrState

                                                                                                                                                func (ByoipCidrState) Values

                                                                                                                                                func (ByoipCidrState) Values() []ByoipCidrState

                                                                                                                                                  Values returns all known values for ByoipCidrState. 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 CancelBatchErrorCode

                                                                                                                                                  type CancelBatchErrorCode string
                                                                                                                                                  const (
                                                                                                                                                  	CancelBatchErrorCodeFleetRequestIdDoesNotExist        CancelBatchErrorCode = "fleetRequestIdDoesNotExist"
                                                                                                                                                  	CancelBatchErrorCodeFleetRequestIdMalformed           CancelBatchErrorCode = "fleetRequestIdMalformed"
                                                                                                                                                  	CancelBatchErrorCodeFleetRequestNotInCancellableState CancelBatchErrorCode = "fleetRequestNotInCancellableState"
                                                                                                                                                  	CancelBatchErrorCodeUnexpectedError                   CancelBatchErrorCode = "unexpectedError"
                                                                                                                                                  )

                                                                                                                                                    Enum values for CancelBatchErrorCode

                                                                                                                                                    func (CancelBatchErrorCode) Values

                                                                                                                                                      Values returns all known values for CancelBatchErrorCode. 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 CancelSpotFleetRequestsError

                                                                                                                                                      type CancelSpotFleetRequestsError struct {
                                                                                                                                                      
                                                                                                                                                      	// The error code.
                                                                                                                                                      	Code CancelBatchErrorCode
                                                                                                                                                      
                                                                                                                                                      	// The description for the error code.
                                                                                                                                                      	Message *string
                                                                                                                                                      }

                                                                                                                                                        Describes a Spot Fleet error.

                                                                                                                                                        type CancelSpotFleetRequestsErrorItem

                                                                                                                                                        type CancelSpotFleetRequestsErrorItem struct {
                                                                                                                                                        
                                                                                                                                                        	// The error.
                                                                                                                                                        	Error *CancelSpotFleetRequestsError
                                                                                                                                                        
                                                                                                                                                        	// The ID of the Spot Fleet request.
                                                                                                                                                        	SpotFleetRequestId *string
                                                                                                                                                        }

                                                                                                                                                          Describes a Spot Fleet request that was not successfully canceled.

                                                                                                                                                          type CancelSpotFleetRequestsSuccessItem

                                                                                                                                                          type CancelSpotFleetRequestsSuccessItem struct {
                                                                                                                                                          
                                                                                                                                                          	// The current state of the Spot Fleet request.
                                                                                                                                                          	CurrentSpotFleetRequestState BatchState
                                                                                                                                                          
                                                                                                                                                          	// The previous state of the Spot Fleet request.
                                                                                                                                                          	PreviousSpotFleetRequestState BatchState
                                                                                                                                                          
                                                                                                                                                          	// The ID of the Spot Fleet request.
                                                                                                                                                          	SpotFleetRequestId *string
                                                                                                                                                          }

                                                                                                                                                            Describes a Spot Fleet request that was successfully canceled.

                                                                                                                                                            type CancelSpotInstanceRequestState

                                                                                                                                                            type CancelSpotInstanceRequestState string
                                                                                                                                                            const (
                                                                                                                                                            	CancelSpotInstanceRequestStateActive    CancelSpotInstanceRequestState = "active"
                                                                                                                                                            	CancelSpotInstanceRequestStateOpen      CancelSpotInstanceRequestState = "open"
                                                                                                                                                            	CancelSpotInstanceRequestStateClosed    CancelSpotInstanceRequestState = "closed"
                                                                                                                                                            	CancelSpotInstanceRequestStateCancelled CancelSpotInstanceRequestState = "cancelled"
                                                                                                                                                            	CancelSpotInstanceRequestStateCompleted CancelSpotInstanceRequestState = "completed"
                                                                                                                                                            )

                                                                                                                                                              Enum values for CancelSpotInstanceRequestState

                                                                                                                                                              func (CancelSpotInstanceRequestState) Values

                                                                                                                                                                Values returns all known values for CancelSpotInstanceRequestState. 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 CancelledSpotInstanceRequest

                                                                                                                                                                type CancelledSpotInstanceRequest struct {
                                                                                                                                                                
                                                                                                                                                                	// The ID of the Spot Instance request.
                                                                                                                                                                	SpotInstanceRequestId *string
                                                                                                                                                                
                                                                                                                                                                	// The state of the Spot Instance request.
                                                                                                                                                                	State CancelSpotInstanceRequestState
                                                                                                                                                                }

                                                                                                                                                                  Describes a request to cancel a Spot Instance.

                                                                                                                                                                  type CapacityReservation

                                                                                                                                                                  type CapacityReservation struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The Availability Zone in which the capacity is reserved.
                                                                                                                                                                  	AvailabilityZone *string
                                                                                                                                                                  
                                                                                                                                                                  	// The Availability Zone ID of the Capacity Reservation.
                                                                                                                                                                  	AvailabilityZoneId *string
                                                                                                                                                                  
                                                                                                                                                                  	// The remaining capacity. Indicates the number of instances that can be launched
                                                                                                                                                                  	// in the Capacity Reservation.
                                                                                                                                                                  	AvailableInstanceCount int32
                                                                                                                                                                  
                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the Capacity Reservation.
                                                                                                                                                                  	CapacityReservationArn *string
                                                                                                                                                                  
                                                                                                                                                                  	// The ID of the Capacity Reservation.
                                                                                                                                                                  	CapacityReservationId *string
                                                                                                                                                                  
                                                                                                                                                                  	// The date and time at which the Capacity Reservation was created.
                                                                                                                                                                  	CreateDate *time.Time
                                                                                                                                                                  
                                                                                                                                                                  	// Indicates whether the Capacity Reservation supports EBS-optimized instances.
                                                                                                                                                                  	// This optimization provides dedicated throughput to Amazon EBS and an optimized
                                                                                                                                                                  	// configuration stack to provide optimal I/O performance. This optimization isn't
                                                                                                                                                                  	// available with all instance types. Additional usage charges apply when using an
                                                                                                                                                                  	// EBS- optimized instance.
                                                                                                                                                                  	EbsOptimized bool
                                                                                                                                                                  
                                                                                                                                                                  	// The date and time at which the Capacity Reservation expires. When a Capacity
                                                                                                                                                                  	// Reservation expires, the reserved capacity is released and you can no longer
                                                                                                                                                                  	// launch instances into it. The Capacity Reservation's state changes to expired
                                                                                                                                                                  	// when it reaches its end date and time.
                                                                                                                                                                  	EndDate *time.Time
                                                                                                                                                                  
                                                                                                                                                                  	// Indicates the way in which the Capacity Reservation ends. A Capacity Reservation
                                                                                                                                                                  	// can have one of the following end types:
                                                                                                                                                                  	//
                                                                                                                                                                  	// * unlimited - The Capacity Reservation
                                                                                                                                                                  	// remains active until you explicitly cancel it.
                                                                                                                                                                  	//
                                                                                                                                                                  	// * limited - The Capacity
                                                                                                                                                                  	// Reservation expires automatically at a specified date and time.
                                                                                                                                                                  	EndDateType EndDateType
                                                                                                                                                                  
                                                                                                                                                                  	// Indicates whether the Capacity Reservation supports instances with temporary,
                                                                                                                                                                  	// block-level storage.
                                                                                                                                                                  	EphemeralStorage bool
                                                                                                                                                                  
                                                                                                                                                                  	// Indicates the type of instance launches that the Capacity Reservation accepts.
                                                                                                                                                                  	// The options include:
                                                                                                                                                                  	//
                                                                                                                                                                  	// * open - The Capacity Reservation accepts all instances
                                                                                                                                                                  	// that have matching attributes (instance type, platform, and Availability Zone).
                                                                                                                                                                  	// Instances that have matching attributes launch into the Capacity Reservation
                                                                                                                                                                  	// automatically without specifying any additional parameters.
                                                                                                                                                                  	//
                                                                                                                                                                  	// * targeted - The
                                                                                                                                                                  	// Capacity Reservation only accepts instances that have matching attributes
                                                                                                                                                                  	// (instance type, platform, and Availability Zone), and explicitly target the
                                                                                                                                                                  	// Capacity Reservation. This ensures that only permitted instances can use the
                                                                                                                                                                  	// reserved capacity.
                                                                                                                                                                  	InstanceMatchCriteria InstanceMatchCriteria
                                                                                                                                                                  
                                                                                                                                                                  	// The type of operating system for which the Capacity Reservation reserves
                                                                                                                                                                  	// capacity.
                                                                                                                                                                  	InstancePlatform CapacityReservationInstancePlatform
                                                                                                                                                                  
                                                                                                                                                                  	// The type of instance for which the Capacity Reservation reserves capacity.
                                                                                                                                                                  	InstanceType *string
                                                                                                                                                                  
                                                                                                                                                                  	// The ID of the AWS account that owns the Capacity Reservation.
                                                                                                                                                                  	OwnerId *string
                                                                                                                                                                  
                                                                                                                                                                  	// The date and time at which the Capacity Reservation was started.
                                                                                                                                                                  	StartDate *time.Time
                                                                                                                                                                  
                                                                                                                                                                  	// The current state of the Capacity Reservation. A Capacity Reservation can be in
                                                                                                                                                                  	// one of the following states:
                                                                                                                                                                  	//
                                                                                                                                                                  	// * active - The Capacity Reservation is active and
                                                                                                                                                                  	// the capacity is available for your use.
                                                                                                                                                                  	//
                                                                                                                                                                  	// * expired - The Capacity Reservation
                                                                                                                                                                  	// expired automatically at the date and time specified in your request. The
                                                                                                                                                                  	// reserved capacity is no longer available for your use.
                                                                                                                                                                  	//
                                                                                                                                                                  	// * cancelled - The
                                                                                                                                                                  	// Capacity Reservation was cancelled. The reserved capacity is no longer available
                                                                                                                                                                  	// for your use.
                                                                                                                                                                  	//
                                                                                                                                                                  	// * pending - The Capacity Reservation request was successful but
                                                                                                                                                                  	// the capacity provisioning is still pending.
                                                                                                                                                                  	//
                                                                                                                                                                  	// * failed - The Capacity Reservation
                                                                                                                                                                  	// request has failed. A request might fail due to invalid request parameters,
                                                                                                                                                                  	// capacity constraints, or instance limit constraints. Failed requests are
                                                                                                                                                                  	// retained for 60 minutes.
                                                                                                                                                                  	State CapacityReservationState
                                                                                                                                                                  
                                                                                                                                                                  	// Any tags assigned to the Capacity Reservation.
                                                                                                                                                                  	Tags []Tag
                                                                                                                                                                  
                                                                                                                                                                  	// Indicates the tenancy of the Capacity Reservation. A Capacity Reservation can
                                                                                                                                                                  	// have one of the following tenancy settings:
                                                                                                                                                                  	//
                                                                                                                                                                  	// * default - The Capacity
                                                                                                                                                                  	// Reservation is created on hardware that is shared with other AWS accounts.
                                                                                                                                                                  	//
                                                                                                                                                                  	// *
                                                                                                                                                                  	// dedicated - The Capacity Reservation is created on single-tenant hardware that
                                                                                                                                                                  	// is dedicated to a single AWS account.
                                                                                                                                                                  	Tenancy CapacityReservationTenancy
                                                                                                                                                                  
                                                                                                                                                                  	// The total number of instances for which the Capacity Reservation reserves
                                                                                                                                                                  	// capacity.
                                                                                                                                                                  	TotalInstanceCount int32
                                                                                                                                                                  }

                                                                                                                                                                    Describes a Capacity Reservation.

                                                                                                                                                                    type CapacityReservationGroup

                                                                                                                                                                    type CapacityReservationGroup struct {
                                                                                                                                                                    
                                                                                                                                                                    	// The ARN of the resource group.
                                                                                                                                                                    	GroupArn *string
                                                                                                                                                                    
                                                                                                                                                                    	// The ID of the AWS account that owns the resource group.
                                                                                                                                                                    	OwnerId *string
                                                                                                                                                                    }

                                                                                                                                                                      Describes a resource group to which a Capacity Reservation has been added.

                                                                                                                                                                      type CapacityReservationInstancePlatform

                                                                                                                                                                      type CapacityReservationInstancePlatform string
                                                                                                                                                                      const (
                                                                                                                                                                      	CapacityReservationInstancePlatformLinuxUnix                      CapacityReservationInstancePlatform = "Linux/UNIX"
                                                                                                                                                                      	CapacityReservationInstancePlatformRedHatEnterpriseLinux          CapacityReservationInstancePlatform = "Red Hat Enterprise Linux"
                                                                                                                                                                      	CapacityReservationInstancePlatformSuseLinux                      CapacityReservationInstancePlatform = "SUSE Linux"
                                                                                                                                                                      	CapacityReservationInstancePlatformWindows                        CapacityReservationInstancePlatform = "Windows"
                                                                                                                                                                      	CapacityReservationInstancePlatformWindowsWithSqlServer           CapacityReservationInstancePlatform = "Windows with SQL Server"
                                                                                                                                                                      	CapacityReservationInstancePlatformWindowsWithSqlServerEnterprise CapacityReservationInstancePlatform = "Windows with SQL Server Enterprise"
                                                                                                                                                                      	CapacityReservationInstancePlatformWindowsWithSqlServerStandard   CapacityReservationInstancePlatform = "Windows with SQL Server Standard"
                                                                                                                                                                      	CapacityReservationInstancePlatformWindowsWithSqlServerWeb        CapacityReservationInstancePlatform = "Windows with SQL Server Web"
                                                                                                                                                                      	CapacityReservationInstancePlatformLinuxWithSqlServerStandard     CapacityReservationInstancePlatform = "Linux with SQL Server Standard"
                                                                                                                                                                      	CapacityReservationInstancePlatformLinuxWithSqlServerWeb          CapacityReservationInstancePlatform = "Linux with SQL Server Web"
                                                                                                                                                                      	CapacityReservationInstancePlatformLinuxWithSqlServerEnterprise   CapacityReservationInstancePlatform = "Linux with SQL Server Enterprise"
                                                                                                                                                                      )

                                                                                                                                                                        Enum values for CapacityReservationInstancePlatform

                                                                                                                                                                        func (CapacityReservationInstancePlatform) Values

                                                                                                                                                                          Values returns all known values for CapacityReservationInstancePlatform. 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 CapacityReservationOptions

                                                                                                                                                                          type CapacityReservationOptions struct {
                                                                                                                                                                          
                                                                                                                                                                          	// Indicates whether to use unused Capacity Reservations for fulfilling On-Demand
                                                                                                                                                                          	// capacity. If you specify use-capacity-reservations-first, the fleet uses unused
                                                                                                                                                                          	// Capacity Reservations to fulfill On-Demand capacity up to the target On-Demand
                                                                                                                                                                          	// capacity. If multiple instance pools have unused Capacity Reservations, the
                                                                                                                                                                          	// On-Demand allocation strategy (lowest-price or prioritized) is applied. If the
                                                                                                                                                                          	// number of unused Capacity Reservations is less than the On-Demand target
                                                                                                                                                                          	// capacity, the remaining On-Demand target capacity is launched according to the
                                                                                                                                                                          	// On-Demand allocation strategy (lowest-price or prioritized). If you do not
                                                                                                                                                                          	// specify a value, the fleet fulfils the On-Demand capacity according to the
                                                                                                                                                                          	// chosen On-Demand allocation strategy.
                                                                                                                                                                          	UsageStrategy FleetCapacityReservationUsageStrategy
                                                                                                                                                                          }

                                                                                                                                                                            Describes the strategy for using unused Capacity Reservations for fulfilling On-Demand capacity. This strategy can only be used if the EC2 Fleet is of type instant. For more information about Capacity Reservations, see On-Demand Capacity Reservations (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-capacity-reservations.html) in the Amazon EC2 User Guide. For examples of using Capacity Reservations in an EC2 Fleet, see EC2 Fleet example configurations (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-examples.html) in the Amazon EC2 User Guide.

                                                                                                                                                                            type CapacityReservationOptionsRequest

                                                                                                                                                                            type CapacityReservationOptionsRequest struct {
                                                                                                                                                                            
                                                                                                                                                                            	// Indicates whether to use unused Capacity Reservations for fulfilling On-Demand
                                                                                                                                                                            	// capacity. If you specify use-capacity-reservations-first, the fleet uses unused
                                                                                                                                                                            	// Capacity Reservations to fulfill On-Demand capacity up to the target On-Demand
                                                                                                                                                                            	// capacity. If multiple instance pools have unused Capacity Reservations, the
                                                                                                                                                                            	// On-Demand allocation strategy (lowest-price or prioritized) is applied. If the
                                                                                                                                                                            	// number of unused Capacity Reservations is less than the On-Demand target
                                                                                                                                                                            	// capacity, the remaining On-Demand target capacity is launched according to the
                                                                                                                                                                            	// On-Demand allocation strategy (lowest-price or prioritized). If you do not
                                                                                                                                                                            	// specify a value, the fleet fulfils the On-Demand capacity according to the
                                                                                                                                                                            	// chosen On-Demand allocation strategy.
                                                                                                                                                                            	UsageStrategy FleetCapacityReservationUsageStrategy
                                                                                                                                                                            }

                                                                                                                                                                              Describes the strategy for using unused Capacity Reservations for fulfilling On-Demand capacity. This strategy can only be used if the EC2 Fleet is of type instant. For more information about Capacity Reservations, see On-Demand Capacity Reservations (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-capacity-reservations.html) in the Amazon EC2 User Guide. For examples of using Capacity Reservations in an EC2 Fleet, see EC2 Fleet example configurations (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-examples.html) in the Amazon EC2 User Guide.

                                                                                                                                                                              type CapacityReservationPreference

                                                                                                                                                                              type CapacityReservationPreference string
                                                                                                                                                                              const (
                                                                                                                                                                              	CapacityReservationPreferenceOpen CapacityReservationPreference = "open"
                                                                                                                                                                              	CapacityReservationPreferenceNone CapacityReservationPreference = "none"
                                                                                                                                                                              )

                                                                                                                                                                                Enum values for CapacityReservationPreference

                                                                                                                                                                                func (CapacityReservationPreference) Values

                                                                                                                                                                                  Values returns all known values for CapacityReservationPreference. 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 CapacityReservationSpecification

                                                                                                                                                                                  type CapacityReservationSpecification struct {
                                                                                                                                                                                  
                                                                                                                                                                                  	// Indicates the instance's Capacity Reservation preferences. Possible preferences
                                                                                                                                                                                  	// include:
                                                                                                                                                                                  	//
                                                                                                                                                                                  	// * open - The instance can run in any open Capacity Reservation that
                                                                                                                                                                                  	// has matching attributes (instance type, platform, Availability Zone).
                                                                                                                                                                                  	//
                                                                                                                                                                                  	// * none -
                                                                                                                                                                                  	// The instance avoids running in a Capacity Reservation even if one is available.
                                                                                                                                                                                  	// The instance runs as an On-Demand Instance.
                                                                                                                                                                                  	CapacityReservationPreference CapacityReservationPreference
                                                                                                                                                                                  
                                                                                                                                                                                  	// Information about the target Capacity Reservation or Capacity Reservation group.
                                                                                                                                                                                  	CapacityReservationTarget *CapacityReservationTarget
                                                                                                                                                                                  }

                                                                                                                                                                                    Describes an instance's Capacity Reservation targeting option. You can specify only one parameter at a time. If you specify CapacityReservationPreference and CapacityReservationTarget, the request fails. Use the CapacityReservationPreference parameter to configure the instance to run as an On-Demand Instance or to run in any open Capacity Reservation that has matching attributes (instance type, platform, Availability Zone). Use the CapacityReservationTarget parameter to explicitly target a specific Capacity Reservation or a Capacity Reservation group.

                                                                                                                                                                                    type CapacityReservationSpecificationResponse

                                                                                                                                                                                    type CapacityReservationSpecificationResponse struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// Describes the instance's Capacity Reservation preferences. Possible preferences
                                                                                                                                                                                    	// include:
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// * open - The instance can run in any open Capacity Reservation that
                                                                                                                                                                                    	// has matching attributes (instance type, platform, Availability Zone).
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// * none -
                                                                                                                                                                                    	// The instance avoids running in a Capacity Reservation even if one is available.
                                                                                                                                                                                    	// The instance runs in On-Demand capacity.
                                                                                                                                                                                    	CapacityReservationPreference CapacityReservationPreference
                                                                                                                                                                                    
                                                                                                                                                                                    	// Information about the targeted Capacity Reservation or Capacity Reservation
                                                                                                                                                                                    	// group.
                                                                                                                                                                                    	CapacityReservationTarget *CapacityReservationTargetResponse
                                                                                                                                                                                    }

                                                                                                                                                                                      Describes the instance's Capacity Reservation targeting preferences. The action returns the capacityReservationPreference response element if the instance is configured to run in On-Demand capacity, or if it is configured in run in any open Capacity Reservation that has matching attributes (instance type, platform, Availability Zone). The action returns the capacityReservationTarget response element if the instance explicily targets a specific Capacity Reservation or Capacity Reservation group.

                                                                                                                                                                                      type CapacityReservationState

                                                                                                                                                                                      type CapacityReservationState string
                                                                                                                                                                                      const (
                                                                                                                                                                                      	CapacityReservationStateActive    CapacityReservationState = "active"
                                                                                                                                                                                      	CapacityReservationStateExpired   CapacityReservationState = "expired"
                                                                                                                                                                                      	CapacityReservationStateCancelled CapacityReservationState = "cancelled"
                                                                                                                                                                                      	CapacityReservationStatePending   CapacityReservationState = "pending"
                                                                                                                                                                                      	CapacityReservationStateFailed    CapacityReservationState = "failed"
                                                                                                                                                                                      )

                                                                                                                                                                                        Enum values for CapacityReservationState

                                                                                                                                                                                        func (CapacityReservationState) Values

                                                                                                                                                                                          Values returns all known values for CapacityReservationState. 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 CapacityReservationTarget

                                                                                                                                                                                          type CapacityReservationTarget struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The ID of the Capacity Reservation in which to run the instance.
                                                                                                                                                                                          	CapacityReservationId *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The ARN of the Capacity Reservation resource group in which to run the instance.
                                                                                                                                                                                          	CapacityReservationResourceGroupArn *string
                                                                                                                                                                                          }

                                                                                                                                                                                            Describes a target Capacity Reservation or Capacity Reservation group.

                                                                                                                                                                                            type CapacityReservationTargetResponse

                                                                                                                                                                                            type CapacityReservationTargetResponse struct {
                                                                                                                                                                                            
                                                                                                                                                                                            	// The ID of the targeted Capacity Reservation.
                                                                                                                                                                                            	CapacityReservationId *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The ARN of the targeted Capacity Reservation group.
                                                                                                                                                                                            	CapacityReservationResourceGroupArn *string
                                                                                                                                                                                            }

                                                                                                                                                                                              Describes a target Capacity Reservation or Capacity Reservation group.

                                                                                                                                                                                              type CapacityReservationTenancy

                                                                                                                                                                                              type CapacityReservationTenancy string
                                                                                                                                                                                              const (
                                                                                                                                                                                              	CapacityReservationTenancyDefault   CapacityReservationTenancy = "default"
                                                                                                                                                                                              	CapacityReservationTenancyDedicated CapacityReservationTenancy = "dedicated"
                                                                                                                                                                                              )

                                                                                                                                                                                                Enum values for CapacityReservationTenancy

                                                                                                                                                                                                func (CapacityReservationTenancy) Values

                                                                                                                                                                                                  Values returns all known values for CapacityReservationTenancy. 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 CarrierGateway

                                                                                                                                                                                                  type CarrierGateway struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The ID of the carrier gateway.
                                                                                                                                                                                                  	CarrierGatewayId *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The AWS account ID of the owner of the carrier gateway.
                                                                                                                                                                                                  	OwnerId *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The state of the carrier gateway.
                                                                                                                                                                                                  	State CarrierGatewayState
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The tags assigned to the carrier gateway.
                                                                                                                                                                                                  	Tags []Tag
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The ID of the VPC associated with the carrier gateway.
                                                                                                                                                                                                  	VpcId *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                    Describes a carrier gateway.

                                                                                                                                                                                                    type CarrierGatewayState

                                                                                                                                                                                                    type CarrierGatewayState string
                                                                                                                                                                                                    const (
                                                                                                                                                                                                    	CarrierGatewayStatePending   CarrierGatewayState = "pending"
                                                                                                                                                                                                    	CarrierGatewayStateAvailable CarrierGatewayState = "available"
                                                                                                                                                                                                    	CarrierGatewayStateDeleting  CarrierGatewayState = "deleting"
                                                                                                                                                                                                    	CarrierGatewayStateDeleted   CarrierGatewayState = "deleted"
                                                                                                                                                                                                    )

                                                                                                                                                                                                      Enum values for CarrierGatewayState

                                                                                                                                                                                                      func (CarrierGatewayState) Values

                                                                                                                                                                                                        Values returns all known values for CarrierGatewayState. 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 CertificateAuthentication

                                                                                                                                                                                                        type CertificateAuthentication struct {
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The ARN of the client certificate.
                                                                                                                                                                                                        	ClientRootCertificateChain *string
                                                                                                                                                                                                        }

                                                                                                                                                                                                          Information about the client certificate used for authentication.

                                                                                                                                                                                                          type CertificateAuthenticationRequest

                                                                                                                                                                                                          type CertificateAuthenticationRequest struct {
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The ARN of the client certificate. The certificate must be signed by a
                                                                                                                                                                                                          	// certificate authority (CA) and it must be provisioned in AWS Certificate Manager
                                                                                                                                                                                                          	// (ACM).
                                                                                                                                                                                                          	ClientRootCertificateChainArn *string
                                                                                                                                                                                                          }

                                                                                                                                                                                                            Information about the client certificate to be used for authentication.

                                                                                                                                                                                                            type CidrAuthorizationContext

                                                                                                                                                                                                            type CidrAuthorizationContext struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The plain-text authorization message for the prefix and account.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The signed authorization message for the prefix and account.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	Signature *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                              Provides authorization for Amazon to bring a specific IP address range to a specific AWS account using bring your own IP addresses (BYOIP). For more information, see Prepare to Bring Your Address Range to Your AWS Account (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html#prepare-for-byoip) in the Amazon Elastic Compute Cloud User Guide.

                                                                                                                                                                                                              type CidrBlock

                                                                                                                                                                                                              type CidrBlock struct {
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// The IPv4 CIDR block.
                                                                                                                                                                                                              	CidrBlock *string
                                                                                                                                                                                                              }

                                                                                                                                                                                                                Describes an IPv4 CIDR block.

                                                                                                                                                                                                                type ClassicLinkDnsSupport

                                                                                                                                                                                                                type ClassicLinkDnsSupport struct {
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// Indicates whether ClassicLink DNS support is enabled for the VPC.
                                                                                                                                                                                                                	ClassicLinkDnsSupported bool
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// The ID of the VPC.
                                                                                                                                                                                                                	VpcId *string
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  Describes the ClassicLink DNS support status of a VPC.

                                                                                                                                                                                                                  type ClassicLinkInstance

                                                                                                                                                                                                                  type ClassicLinkInstance struct {
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// A list of security groups.
                                                                                                                                                                                                                  	Groups []GroupIdentifier
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The ID of the instance.
                                                                                                                                                                                                                  	InstanceId *string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Any tags assigned to the instance.
                                                                                                                                                                                                                  	Tags []Tag
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The ID of the VPC.
                                                                                                                                                                                                                  	VpcId *string
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    Describes a linked EC2-Classic instance.

                                                                                                                                                                                                                    type ClassicLoadBalancer

                                                                                                                                                                                                                    type ClassicLoadBalancer struct {
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The name of the load balancer.
                                                                                                                                                                                                                    	Name *string
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      Describes a Classic Load Balancer.

                                                                                                                                                                                                                      type ClassicLoadBalancersConfig

                                                                                                                                                                                                                      type ClassicLoadBalancersConfig struct {
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// One or more Classic Load Balancers.
                                                                                                                                                                                                                      	ClassicLoadBalancers []ClassicLoadBalancer
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        Describes the Classic Load Balancers to attach to a Spot Fleet. Spot Fleet registers the running Spot Instances with these Classic Load Balancers.

                                                                                                                                                                                                                        type ClientCertificateRevocationListStatus

                                                                                                                                                                                                                        type ClientCertificateRevocationListStatus struct {
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// The state of the client certificate revocation list.
                                                                                                                                                                                                                        	Code ClientCertificateRevocationListStatusCode
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// A message about the status of the client certificate revocation list, if
                                                                                                                                                                                                                        	// applicable.
                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          Describes the state of a client certificate revocation list.

                                                                                                                                                                                                                          type ClientCertificateRevocationListStatusCode

                                                                                                                                                                                                                          type ClientCertificateRevocationListStatusCode string
                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                          	ClientCertificateRevocationListStatusCodePending ClientCertificateRevocationListStatusCode = "pending"
                                                                                                                                                                                                                          	ClientCertificateRevocationListStatusCodeActive  ClientCertificateRevocationListStatusCode = "active"
                                                                                                                                                                                                                          )

                                                                                                                                                                                                                            Enum values for ClientCertificateRevocationListStatusCode

                                                                                                                                                                                                                            func (ClientCertificateRevocationListStatusCode) Values

                                                                                                                                                                                                                              Values returns all known values for ClientCertificateRevocationListStatusCode. 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 ClientConnectOptions

                                                                                                                                                                                                                              type ClientConnectOptions struct {
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// Indicates whether client connect options are enabled. The default is false (not
                                                                                                                                                                                                                              	// enabled).
                                                                                                                                                                                                                              	Enabled bool
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the AWS Lambda function used for connection
                                                                                                                                                                                                                              	// authorization.
                                                                                                                                                                                                                              	LambdaFunctionArn *string
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                The options for managing connection authorization for new client connections.

                                                                                                                                                                                                                                type ClientConnectResponseOptions

                                                                                                                                                                                                                                type ClientConnectResponseOptions struct {
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// Indicates whether client connect options are enabled.
                                                                                                                                                                                                                                	Enabled bool
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// The Amazon Resource Name (ARN) of the AWS Lambda function used for connection
                                                                                                                                                                                                                                	// authorization.
                                                                                                                                                                                                                                	LambdaFunctionArn *string
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// The status of any updates to the client connect options.
                                                                                                                                                                                                                                	Status *ClientVpnEndpointAttributeStatus
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  The options for managing connection authorization for new client connections.

                                                                                                                                                                                                                                  type ClientData

                                                                                                                                                                                                                                  type ClientData struct {
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// A user-defined comment about the disk upload.
                                                                                                                                                                                                                                  	Comment *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The time that the disk upload ends.
                                                                                                                                                                                                                                  	UploadEnd *time.Time
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The size of the uploaded disk image, in GiB.
                                                                                                                                                                                                                                  	UploadSize float64
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The time that the disk upload starts.
                                                                                                                                                                                                                                  	UploadStart *time.Time
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    Describes the client-specific data.

                                                                                                                                                                                                                                    type ClientVpnAuthentication

                                                                                                                                                                                                                                    type ClientVpnAuthentication struct {
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// Information about the Active Directory, if applicable.
                                                                                                                                                                                                                                    	ActiveDirectory *DirectoryServiceAuthentication
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// Information about the IAM SAML identity provider, if applicable.
                                                                                                                                                                                                                                    	FederatedAuthentication *FederatedAuthentication
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// Information about the authentication certificates, if applicable.
                                                                                                                                                                                                                                    	MutualAuthentication *CertificateAuthentication
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The authentication type used.
                                                                                                                                                                                                                                    	Type ClientVpnAuthenticationType
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      Describes the authentication methods used by a Client VPN endpoint. For more information, see Authentication (https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/client-authentication.html) in the AWS Client VPN Administrator Guide.

                                                                                                                                                                                                                                      type ClientVpnAuthenticationRequest

                                                                                                                                                                                                                                      type ClientVpnAuthenticationRequest struct {
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// Information about the Active Directory to be used, if applicable. You must
                                                                                                                                                                                                                                      	// provide this information if Type is directory-service-authentication.
                                                                                                                                                                                                                                      	ActiveDirectory *DirectoryServiceAuthenticationRequest
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// Information about the IAM SAML identity provider to be used, if applicable. You
                                                                                                                                                                                                                                      	// must provide this information if Type is federated-authentication.
                                                                                                                                                                                                                                      	FederatedAuthentication *FederatedAuthenticationRequest
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// Information about the authentication certificates to be used, if applicable. You
                                                                                                                                                                                                                                      	// must provide this information if Type is certificate-authentication.
                                                                                                                                                                                                                                      	MutualAuthentication *CertificateAuthenticationRequest
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The type of client authentication to be used.
                                                                                                                                                                                                                                      	Type ClientVpnAuthenticationType
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        Describes the authentication method to be used by a Client VPN endpoint. For more information, see Authentication (https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/authentication-authrization.html#client-authentication) in the AWS Client VPN Administrator Guide.

                                                                                                                                                                                                                                        type ClientVpnAuthenticationType

                                                                                                                                                                                                                                        type ClientVpnAuthenticationType string
                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                        	ClientVpnAuthenticationTypeCertificateAuthentication      ClientVpnAuthenticationType = "certificate-authentication"
                                                                                                                                                                                                                                        	ClientVpnAuthenticationTypeDirectoryServiceAuthentication ClientVpnAuthenticationType = "directory-service-authentication"
                                                                                                                                                                                                                                        	ClientVpnAuthenticationTypeFederatedAuthentication        ClientVpnAuthenticationType = "federated-authentication"
                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                          Enum values for ClientVpnAuthenticationType

                                                                                                                                                                                                                                          func (ClientVpnAuthenticationType) Values

                                                                                                                                                                                                                                            Values returns all known values for ClientVpnAuthenticationType. 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 ClientVpnAuthorizationRuleStatus

                                                                                                                                                                                                                                            type ClientVpnAuthorizationRuleStatus struct {
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The state of the authorization rule.
                                                                                                                                                                                                                                            	Code ClientVpnAuthorizationRuleStatusCode
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// A message about the status of the authorization rule, if applicable.
                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              Describes the state of an authorization rule.

                                                                                                                                                                                                                                              type ClientVpnAuthorizationRuleStatusCode

                                                                                                                                                                                                                                              type ClientVpnAuthorizationRuleStatusCode string
                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                              	ClientVpnAuthorizationRuleStatusCodeAuthorizing ClientVpnAuthorizationRuleStatusCode = "authorizing"
                                                                                                                                                                                                                                              	ClientVpnAuthorizationRuleStatusCodeActive      ClientVpnAuthorizationRuleStatusCode = "active"
                                                                                                                                                                                                                                              	ClientVpnAuthorizationRuleStatusCodeFailed      ClientVpnAuthorizationRuleStatusCode = "failed"
                                                                                                                                                                                                                                              	ClientVpnAuthorizationRuleStatusCodeRevoking    ClientVpnAuthorizationRuleStatusCode = "revoking"
                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                Enum values for ClientVpnAuthorizationRuleStatusCode

                                                                                                                                                                                                                                                func (ClientVpnAuthorizationRuleStatusCode) Values

                                                                                                                                                                                                                                                  Values returns all known values for ClientVpnAuthorizationRuleStatusCode. 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 ClientVpnConnection

                                                                                                                                                                                                                                                  type ClientVpnConnection struct {
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The IP address of the client.
                                                                                                                                                                                                                                                  	ClientIp *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The ID of the Client VPN endpoint to which the client is connected.
                                                                                                                                                                                                                                                  	ClientVpnEndpointId *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The common name associated with the client. This is either the name of the
                                                                                                                                                                                                                                                  	// client certificate, or the Active Directory user name.
                                                                                                                                                                                                                                                  	CommonName *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The date and time the client connection was terminated.
                                                                                                                                                                                                                                                  	ConnectionEndTime *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The date and time the client connection was established.
                                                                                                                                                                                                                                                  	ConnectionEstablishedTime *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The ID of the client connection.
                                                                                                                                                                                                                                                  	ConnectionId *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The number of bytes received by the client.
                                                                                                                                                                                                                                                  	EgressBytes *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The number of packets received by the client.
                                                                                                                                                                                                                                                  	EgressPackets *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The number of bytes sent by the client.
                                                                                                                                                                                                                                                  	IngressBytes *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The number of packets sent by the client.
                                                                                                                                                                                                                                                  	IngressPackets *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The statuses returned by the client connect handler for posture compliance, if
                                                                                                                                                                                                                                                  	// applicable.
                                                                                                                                                                                                                                                  	PostureComplianceStatuses []string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The current state of the client connection.
                                                                                                                                                                                                                                                  	Status *ClientVpnConnectionStatus
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The current date and time.
                                                                                                                                                                                                                                                  	Timestamp *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The username of the client who established the client connection. This
                                                                                                                                                                                                                                                  	// information is only provided if Active Directory client authentication is used.
                                                                                                                                                                                                                                                  	Username *string
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    Describes a client connection.

                                                                                                                                                                                                                                                    type ClientVpnConnectionStatus

                                                                                                                                                                                                                                                    type ClientVpnConnectionStatus struct {
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// The state of the client connection.
                                                                                                                                                                                                                                                    	Code ClientVpnConnectionStatusCode
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// A message about the status of the client connection, if applicable.
                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      Describes the status of a client connection.

                                                                                                                                                                                                                                                      type ClientVpnConnectionStatusCode

                                                                                                                                                                                                                                                      type ClientVpnConnectionStatusCode string
                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                      	ClientVpnConnectionStatusCodeActive            ClientVpnConnectionStatusCode = "active"
                                                                                                                                                                                                                                                      	ClientVpnConnectionStatusCodeFailedToTerminate ClientVpnConnectionStatusCode = "failed-to-terminate"
                                                                                                                                                                                                                                                      	ClientVpnConnectionStatusCodeTerminating       ClientVpnConnectionStatusCode = "terminating"
                                                                                                                                                                                                                                                      	ClientVpnConnectionStatusCodeTerminated        ClientVpnConnectionStatusCode = "terminated"
                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                        Enum values for ClientVpnConnectionStatusCode

                                                                                                                                                                                                                                                        func (ClientVpnConnectionStatusCode) Values

                                                                                                                                                                                                                                                          Values returns all known values for ClientVpnConnectionStatusCode. 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 ClientVpnEndpoint

                                                                                                                                                                                                                                                          type ClientVpnEndpoint struct {
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Information about the associated target networks. A target network is a subnet
                                                                                                                                                                                                                                                          	// in a VPC.
                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                          	// Deprecated: This property is deprecated. To view the target networks associated
                                                                                                                                                                                                                                                          	// with a Client VPN endpoint, call DescribeClientVpnTargetNetworks and inspect the
                                                                                                                                                                                                                                                          	// clientVpnTargetNetworks response element.
                                                                                                                                                                                                                                                          	AssociatedTargetNetworks []AssociatedTargetNetwork
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Information about the authentication method used by the Client VPN endpoint.
                                                                                                                                                                                                                                                          	AuthenticationOptions []ClientVpnAuthentication
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The IPv4 address range, in CIDR notation, from which client IP addresses are
                                                                                                                                                                                                                                                          	// assigned.
                                                                                                                                                                                                                                                          	ClientCidrBlock *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The options for managing connection authorization for new client connections.
                                                                                                                                                                                                                                                          	ClientConnectOptions *ClientConnectResponseOptions
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The ID of the Client VPN endpoint.
                                                                                                                                                                                                                                                          	ClientVpnEndpointId *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Information about the client connection logging options for the Client VPN
                                                                                                                                                                                                                                                          	// endpoint.
                                                                                                                                                                                                                                                          	ConnectionLogOptions *ConnectionLogResponseOptions
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The date and time the Client VPN endpoint was created.
                                                                                                                                                                                                                                                          	CreationTime *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The date and time the Client VPN endpoint was deleted, if applicable.
                                                                                                                                                                                                                                                          	DeletionTime *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// A brief description of the endpoint.
                                                                                                                                                                                                                                                          	Description *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The DNS name to be used by clients when connecting to the Client VPN endpoint.
                                                                                                                                                                                                                                                          	DnsName *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Information about the DNS servers to be used for DNS resolution.
                                                                                                                                                                                                                                                          	DnsServers []string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The IDs of the security groups for the target network.
                                                                                                                                                                                                                                                          	SecurityGroupIds []string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The URL of the self-service portal.
                                                                                                                                                                                                                                                          	SelfServicePortalUrl *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The ARN of the server certificate.
                                                                                                                                                                                                                                                          	ServerCertificateArn *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Indicates whether split-tunnel is enabled in the AWS Client VPN endpoint. For
                                                                                                                                                                                                                                                          	// information about split-tunnel VPN endpoints, see Split-Tunnel AWS Client VPN
                                                                                                                                                                                                                                                          	// Endpoint
                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/split-tunnel-vpn.html)
                                                                                                                                                                                                                                                          	// in the AWS Client VPN Administrator Guide.
                                                                                                                                                                                                                                                          	SplitTunnel bool
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The current state of the Client VPN endpoint.
                                                                                                                                                                                                                                                          	Status *ClientVpnEndpointStatus
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Any tags assigned to the Client VPN endpoint.
                                                                                                                                                                                                                                                          	Tags []Tag
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The transport protocol used by the Client VPN endpoint.
                                                                                                                                                                                                                                                          	TransportProtocol TransportProtocol
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The ID of the VPC.
                                                                                                                                                                                                                                                          	VpcId *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The port number for the Client VPN endpoint.
                                                                                                                                                                                                                                                          	VpnPort int32
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The protocol used by the VPN session.
                                                                                                                                                                                                                                                          	VpnProtocol VpnProtocol
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            Describes a Client VPN endpoint.

                                                                                                                                                                                                                                                            type ClientVpnEndpointAttributeStatus

                                                                                                                                                                                                                                                            type ClientVpnEndpointAttributeStatus struct {
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The status code.
                                                                                                                                                                                                                                                            	Code ClientVpnEndpointAttributeStatusCode
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The status message.
                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              Describes the status of the Client VPN endpoint attribute.

                                                                                                                                                                                                                                                              type ClientVpnEndpointAttributeStatusCode

                                                                                                                                                                                                                                                              type ClientVpnEndpointAttributeStatusCode string
                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                              	ClientVpnEndpointAttributeStatusCodeApplying ClientVpnEndpointAttributeStatusCode = "applying"
                                                                                                                                                                                                                                                              	ClientVpnEndpointAttributeStatusCodeApplied  ClientVpnEndpointAttributeStatusCode = "applied"
                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                Enum values for ClientVpnEndpointAttributeStatusCode

                                                                                                                                                                                                                                                                func (ClientVpnEndpointAttributeStatusCode) Values

                                                                                                                                                                                                                                                                  Values returns all known values for ClientVpnEndpointAttributeStatusCode. 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 ClientVpnEndpointStatus

                                                                                                                                                                                                                                                                  type ClientVpnEndpointStatus struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The state of the Client VPN endpoint. Possible states include:
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// pending-associate - The Client VPN endpoint has been created but no target
                                                                                                                                                                                                                                                                  	// networks have been associated. The Client VPN endpoint cannot accept
                                                                                                                                                                                                                                                                  	// connections.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * available - The Client VPN endpoint has been created and a
                                                                                                                                                                                                                                                                  	// target network has been associated. The Client VPN endpoint can accept
                                                                                                                                                                                                                                                                  	// connections.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * deleting - The Client VPN endpoint is being deleted. The Client
                                                                                                                                                                                                                                                                  	// VPN endpoint cannot accept connections.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * deleted - The Client VPN endpoint has
                                                                                                                                                                                                                                                                  	// been deleted. The Client VPN endpoint cannot accept connections.
                                                                                                                                                                                                                                                                  	Code ClientVpnEndpointStatusCode
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// A message about the status of the Client VPN endpoint.
                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    Describes the state of a Client VPN endpoint.

                                                                                                                                                                                                                                                                    type ClientVpnEndpointStatusCode

                                                                                                                                                                                                                                                                    type ClientVpnEndpointStatusCode string
                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                    	ClientVpnEndpointStatusCodePendingAssociate ClientVpnEndpointStatusCode = "pending-associate"
                                                                                                                                                                                                                                                                    	ClientVpnEndpointStatusCodeAvailable        ClientVpnEndpointStatusCode = "available"
                                                                                                                                                                                                                                                                    	ClientVpnEndpointStatusCodeDeleting         ClientVpnEndpointStatusCode = "deleting"
                                                                                                                                                                                                                                                                    	ClientVpnEndpointStatusCodeDeleted          ClientVpnEndpointStatusCode = "deleted"
                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                      Enum values for ClientVpnEndpointStatusCode

                                                                                                                                                                                                                                                                      func (ClientVpnEndpointStatusCode) Values

                                                                                                                                                                                                                                                                        Values returns all known values for ClientVpnEndpointStatusCode. 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 ClientVpnRoute

                                                                                                                                                                                                                                                                        type ClientVpnRoute struct {
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// The ID of the Client VPN endpoint with which the route is associated.
                                                                                                                                                                                                                                                                        	ClientVpnEndpointId *string
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// A brief description of the route.
                                                                                                                                                                                                                                                                        	Description *string
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// The IPv4 address range, in CIDR notation, of the route destination.
                                                                                                                                                                                                                                                                        	DestinationCidr *string
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Indicates how the route was associated with the Client VPN endpoint. associate
                                                                                                                                                                                                                                                                        	// indicates that the route was automatically added when the target network was
                                                                                                                                                                                                                                                                        	// associated with the Client VPN endpoint. add-route indicates that the route was
                                                                                                                                                                                                                                                                        	// manually added using the CreateClientVpnRoute action.
                                                                                                                                                                                                                                                                        	Origin *string
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// The current state of the route.
                                                                                                                                                                                                                                                                        	Status *ClientVpnRouteStatus
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// The ID of the subnet through which traffic is routed.
                                                                                                                                                                                                                                                                        	TargetSubnet *string
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// The route type.
                                                                                                                                                                                                                                                                        	Type *string
                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                          Information about a Client VPN endpoint route.

                                                                                                                                                                                                                                                                          type ClientVpnRouteStatus

                                                                                                                                                                                                                                                                          type ClientVpnRouteStatus struct {
                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                          	// The state of the Client VPN endpoint route.
                                                                                                                                                                                                                                                                          	Code ClientVpnRouteStatusCode
                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                          	// A message about the status of the Client VPN endpoint route, if applicable.
                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            Describes the state of a Client VPN endpoint route.

                                                                                                                                                                                                                                                                            type ClientVpnRouteStatusCode

                                                                                                                                                                                                                                                                            type ClientVpnRouteStatusCode string
                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                            	ClientVpnRouteStatusCodeCreating ClientVpnRouteStatusCode = "creating"
                                                                                                                                                                                                                                                                            	ClientVpnRouteStatusCodeActive   ClientVpnRouteStatusCode = "active"
                                                                                                                                                                                                                                                                            	ClientVpnRouteStatusCodeFailed   ClientVpnRouteStatusCode = "failed"
                                                                                                                                                                                                                                                                            	ClientVpnRouteStatusCodeDeleting ClientVpnRouteStatusCode = "deleting"
                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                              Enum values for ClientVpnRouteStatusCode

                                                                                                                                                                                                                                                                              func (ClientVpnRouteStatusCode) Values

                                                                                                                                                                                                                                                                                Values returns all known values for ClientVpnRouteStatusCode. 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 CoipAddressUsage

                                                                                                                                                                                                                                                                                type CoipAddressUsage struct {
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// The allocation ID of the address.
                                                                                                                                                                                                                                                                                	AllocationId *string
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// The AWS account ID.
                                                                                                                                                                                                                                                                                	AwsAccountId *string
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// The AWS service.
                                                                                                                                                                                                                                                                                	AwsService *string
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// The customer-owned IP address.
                                                                                                                                                                                                                                                                                	CoIp *string
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                  Describes address usage for a customer-owned address pool.

                                                                                                                                                                                                                                                                                  type CoipPool

                                                                                                                                                                                                                                                                                  type CoipPool struct {
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The ID of the local gateway route table.
                                                                                                                                                                                                                                                                                  	LocalGatewayRouteTableId *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The ARN of the address pool.
                                                                                                                                                                                                                                                                                  	PoolArn *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The address ranges of the address pool.
                                                                                                                                                                                                                                                                                  	PoolCidrs []string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The ID of the address pool.
                                                                                                                                                                                                                                                                                  	PoolId *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The tags.
                                                                                                                                                                                                                                                                                  	Tags []Tag
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    Describes a customer-owned address pool.

                                                                                                                                                                                                                                                                                    type ConnectionLogOptions

                                                                                                                                                                                                                                                                                    type ConnectionLogOptions struct {
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                    	// The name of the CloudWatch Logs log group. Required if connection logging is
                                                                                                                                                                                                                                                                                    	// enabled.
                                                                                                                                                                                                                                                                                    	CloudwatchLogGroup *string
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                    	// The name of the CloudWatch Logs log stream to which the connection data is
                                                                                                                                                                                                                                                                                    	// published.
                                                                                                                                                                                                                                                                                    	CloudwatchLogStream *string
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                    	// Indicates whether connection logging is enabled.
                                                                                                                                                                                                                                                                                    	Enabled bool
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      Describes the client connection logging options for the Client VPN endpoint.

                                                                                                                                                                                                                                                                                      type ConnectionLogResponseOptions

                                                                                                                                                                                                                                                                                      type ConnectionLogResponseOptions struct {
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// The name of the Amazon CloudWatch Logs log group to which connection logging
                                                                                                                                                                                                                                                                                      	// data is published.
                                                                                                                                                                                                                                                                                      	CloudwatchLogGroup *string
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// The name of the Amazon CloudWatch Logs log stream to which connection logging
                                                                                                                                                                                                                                                                                      	// data is published.
                                                                                                                                                                                                                                                                                      	CloudwatchLogStream *string
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// Indicates whether client connection logging is enabled for the Client VPN
                                                                                                                                                                                                                                                                                      	// endpoint.
                                                                                                                                                                                                                                                                                      	Enabled bool
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        Information about the client connection logging options for a Client VPN endpoint.

                                                                                                                                                                                                                                                                                        type ConnectionNotification

                                                                                                                                                                                                                                                                                        type ConnectionNotification struct {
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The events for the notification. Valid values are Accept, Connect, Delete, and
                                                                                                                                                                                                                                                                                        	// Reject.
                                                                                                                                                                                                                                                                                        	ConnectionEvents []string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The ARN of the SNS topic for the notification.
                                                                                                                                                                                                                                                                                        	ConnectionNotificationArn *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The ID of the notification.
                                                                                                                                                                                                                                                                                        	ConnectionNotificationId *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The state of the notification.
                                                                                                                                                                                                                                                                                        	ConnectionNotificationState ConnectionNotificationState
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The type of notification.
                                                                                                                                                                                                                                                                                        	ConnectionNotificationType ConnectionNotificationType
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The ID of the endpoint service.
                                                                                                                                                                                                                                                                                        	ServiceId *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The ID of the VPC endpoint.
                                                                                                                                                                                                                                                                                        	VpcEndpointId *string
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          Describes a connection notification for a VPC endpoint or VPC endpoint service.

                                                                                                                                                                                                                                                                                          type ConnectionNotificationState

                                                                                                                                                                                                                                                                                          type ConnectionNotificationState string
                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                          	ConnectionNotificationStateEnabled  ConnectionNotificationState = "Enabled"
                                                                                                                                                                                                                                                                                          	ConnectionNotificationStateDisabled ConnectionNotificationState = "Disabled"
                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                            Enum values for ConnectionNotificationState

                                                                                                                                                                                                                                                                                            func (ConnectionNotificationState) Values

                                                                                                                                                                                                                                                                                              Values returns all known values for ConnectionNotificationState. 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 ConnectionNotificationType

                                                                                                                                                                                                                                                                                              type ConnectionNotificationType string
                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                              	ConnectionNotificationTypeTopic ConnectionNotificationType = "Topic"
                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                Enum values for ConnectionNotificationType

                                                                                                                                                                                                                                                                                                func (ConnectionNotificationType) Values

                                                                                                                                                                                                                                                                                                  Values returns all known values for ConnectionNotificationType. 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 ContainerFormat

                                                                                                                                                                                                                                                                                                  type ContainerFormat string
                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                  	ContainerFormatOva ContainerFormat = "ova"
                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                    Enum values for ContainerFormat

                                                                                                                                                                                                                                                                                                    func (ContainerFormat) Values

                                                                                                                                                                                                                                                                                                    func (ContainerFormat) Values() []ContainerFormat

                                                                                                                                                                                                                                                                                                      Values returns all known values for ContainerFormat. 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 ConversionTask

                                                                                                                                                                                                                                                                                                      type ConversionTask struct {
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// The ID of the conversion task.
                                                                                                                                                                                                                                                                                                      	ConversionTaskId *string
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// The time when the task expires. If the upload isn't complete before the
                                                                                                                                                                                                                                                                                                      	// expiration time, we automatically cancel the task.
                                                                                                                                                                                                                                                                                                      	ExpirationTime *string
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// If the task is for importing an instance, this contains information about the
                                                                                                                                                                                                                                                                                                      	// import instance task.
                                                                                                                                                                                                                                                                                                      	ImportInstance *ImportInstanceTaskDetails
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// If the task is for importing a volume, this contains information about the
                                                                                                                                                                                                                                                                                                      	// import volume task.
                                                                                                                                                                                                                                                                                                      	ImportVolume *ImportVolumeTaskDetails
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// The state of the conversion task.
                                                                                                                                                                                                                                                                                                      	State ConversionTaskState
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// The status message related to the conversion task.
                                                                                                                                                                                                                                                                                                      	StatusMessage *string
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// Any tags assigned to the task.
                                                                                                                                                                                                                                                                                                      	Tags []Tag
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        Describes a conversion task.

                                                                                                                                                                                                                                                                                                        type ConversionTaskState

                                                                                                                                                                                                                                                                                                        type ConversionTaskState string
                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                        	ConversionTaskStateActive     ConversionTaskState = "active"
                                                                                                                                                                                                                                                                                                        	ConversionTaskStateCancelling ConversionTaskState = "cancelling"
                                                                                                                                                                                                                                                                                                        	ConversionTaskStateCancelled  ConversionTaskState = "cancelled"
                                                                                                                                                                                                                                                                                                        	ConversionTaskStateCompleted  ConversionTaskState = "completed"
                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                          Enum values for ConversionTaskState

                                                                                                                                                                                                                                                                                                          func (ConversionTaskState) Values

                                                                                                                                                                                                                                                                                                            Values returns all known values for ConversionTaskState. 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 CopyTagsFromSource

                                                                                                                                                                                                                                                                                                            type CopyTagsFromSource string
                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                            	CopyTagsFromSourceVolume CopyTagsFromSource = "volume"
                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                              Enum values for CopyTagsFromSource

                                                                                                                                                                                                                                                                                                              func (CopyTagsFromSource) Values

                                                                                                                                                                                                                                                                                                                Values returns all known values for CopyTagsFromSource. 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 CpuOptions

                                                                                                                                                                                                                                                                                                                type CpuOptions struct {
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// The number of CPU cores for the instance.
                                                                                                                                                                                                                                                                                                                	CoreCount int32
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// The number of threads per CPU core.
                                                                                                                                                                                                                                                                                                                	ThreadsPerCore int32
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                  The CPU options for the instance.

                                                                                                                                                                                                                                                                                                                  type CpuOptionsRequest

                                                                                                                                                                                                                                                                                                                  type CpuOptionsRequest struct {
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The number of CPU cores for the instance.
                                                                                                                                                                                                                                                                                                                  	CoreCount int32
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The number of threads per CPU core. To disable multithreading for the instance,
                                                                                                                                                                                                                                                                                                                  	// specify a value of 1. Otherwise, specify the default value of 2.
                                                                                                                                                                                                                                                                                                                  	ThreadsPerCore int32
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                    The CPU options for the instance. Both the core count and threads per core must be specified in the request.

                                                                                                                                                                                                                                                                                                                    type CreateFleetError

                                                                                                                                                                                                                                                                                                                    type CreateFleetError struct {
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The error code that indicates why the instance could not be launched. For more
                                                                                                                                                                                                                                                                                                                    	// information about error codes, see Error Codes
                                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/errors-overview.html.html).
                                                                                                                                                                                                                                                                                                                    	ErrorCode *string
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The error message that describes why the instance could not be launched. For
                                                                                                                                                                                                                                                                                                                    	// more information about error messages, see Error Codes
                                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/errors-overview.html.html).
                                                                                                                                                                                                                                                                                                                    	ErrorMessage *string
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The launch templates and overrides that were used for launching the instances.
                                                                                                                                                                                                                                                                                                                    	// The values that you specify in the Overrides replace the values in the launch
                                                                                                                                                                                                                                                                                                                    	// template.
                                                                                                                                                                                                                                                                                                                    	LaunchTemplateAndOverrides *LaunchTemplateAndOverridesResponse
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// Indicates if the instance that could not be launched was a Spot Instance or
                                                                                                                                                                                                                                                                                                                    	// On-Demand Instance.
                                                                                                                                                                                                                                                                                                                    	Lifecycle InstanceLifecycle
                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                      Describes the instances that could not be launched by the fleet.

                                                                                                                                                                                                                                                                                                                      type CreateFleetInstance

                                                                                                                                                                                                                                                                                                                      type CreateFleetInstance struct {
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The IDs of the instances.
                                                                                                                                                                                                                                                                                                                      	InstanceIds []string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The instance type.
                                                                                                                                                                                                                                                                                                                      	InstanceType InstanceType
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The launch templates and overrides that were used for launching the instances.
                                                                                                                                                                                                                                                                                                                      	// The values that you specify in the Overrides replace the values in the launch
                                                                                                                                                                                                                                                                                                                      	// template.
                                                                                                                                                                                                                                                                                                                      	LaunchTemplateAndOverrides *LaunchTemplateAndOverridesResponse
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// Indicates if the instance that was launched is a Spot Instance or On-Demand
                                                                                                                                                                                                                                                                                                                      	// Instance.
                                                                                                                                                                                                                                                                                                                      	Lifecycle InstanceLifecycle
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The value is Windows for Windows instances. Otherwise, the value is blank.
                                                                                                                                                                                                                                                                                                                      	Platform PlatformValues
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        Describes the instances that were launched by the fleet.

                                                                                                                                                                                                                                                                                                                        type CreateTransitGatewayConnectRequestOptions

                                                                                                                                                                                                                                                                                                                        type CreateTransitGatewayConnectRequestOptions struct {
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The tunnel protocol.
                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                        	Protocol ProtocolValue
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          The options for a Connect attachment.

                                                                                                                                                                                                                                                                                                                          type CreateTransitGatewayMulticastDomainRequestOptions

                                                                                                                                                                                                                                                                                                                          type CreateTransitGatewayMulticastDomainRequestOptions struct {
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          	// Indicates whether to automatically accept cross-account subnet associations that
                                                                                                                                                                                                                                                                                                                          	// are associated with the transit gateway multicast domain.
                                                                                                                                                                                                                                                                                                                          	AutoAcceptSharedAssociations AutoAcceptSharedAssociationsValue
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          	// Specify whether to enable Internet Group Management Protocol (IGMP) version 2
                                                                                                                                                                                                                                                                                                                          	// for the transit gateway multicast domain.
                                                                                                                                                                                                                                                                                                                          	Igmpv2Support Igmpv2SupportValue
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          	// Specify whether to enable support for statically configuring multicast group
                                                                                                                                                                                                                                                                                                                          	// sources for a domain.
                                                                                                                                                                                                                                                                                                                          	StaticSourcesSupport StaticSourcesSupportValue
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            The options for the transit gateway multicast domain.

                                                                                                                                                                                                                                                                                                                            type CreateTransitGatewayVpcAttachmentRequestOptions

                                                                                                                                                                                                                                                                                                                            type CreateTransitGatewayVpcAttachmentRequestOptions struct {
                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                            	// Enable or disable support for appliance mode. If enabled, a traffic flow between
                                                                                                                                                                                                                                                                                                                            	// a source and destination uses the same Availability Zone for the VPC attachment
                                                                                                                                                                                                                                                                                                                            	// for the lifetime of that flow. The default is disable.
                                                                                                                                                                                                                                                                                                                            	ApplianceModeSupport ApplianceModeSupportValue
                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                            	// Enable or disable DNS support. The default is enable.
                                                                                                                                                                                                                                                                                                                            	DnsSupport DnsSupportValue
                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                            	// Enable or disable IPv6 support. The default is disable.
                                                                                                                                                                                                                                                                                                                            	Ipv6Support Ipv6SupportValue
                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                              Describes the options for a VPC attachment.

                                                                                                                                                                                                                                                                                                                              type CreateVolumePermission

                                                                                                                                                                                                                                                                                                                              type CreateVolumePermission struct {
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// The group to be added or removed. The possible value is all.
                                                                                                                                                                                                                                                                                                                              	Group PermissionGroup
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// The AWS account ID to be added or removed.
                                                                                                                                                                                                                                                                                                                              	UserId *string
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                Describes the user or group to be added or removed from the list of create volume permissions for a volume.

                                                                                                                                                                                                                                                                                                                                type CreateVolumePermissionModifications

                                                                                                                                                                                                                                                                                                                                type CreateVolumePermissionModifications struct {
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// Adds the specified AWS account ID or group to the list.
                                                                                                                                                                                                                                                                                                                                	Add []CreateVolumePermission
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// Removes the specified AWS account ID or group from the list.
                                                                                                                                                                                                                                                                                                                                	Remove []CreateVolumePermission
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  Describes modifications to the list of create volume permissions for a volume.

                                                                                                                                                                                                                                                                                                                                  type CreditSpecification

                                                                                                                                                                                                                                                                                                                                  type CreditSpecification struct {
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The credit option for CPU usage of a T2, T3, or T3a instance. Valid values are
                                                                                                                                                                                                                                                                                                                                  	// standard and unlimited.
                                                                                                                                                                                                                                                                                                                                  	CpuCredits *string
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    Describes the credit option for CPU usage of a T2, T3, or T3a instance.

                                                                                                                                                                                                                                                                                                                                    type CreditSpecificationRequest

                                                                                                                                                                                                                                                                                                                                    type CreditSpecificationRequest struct {
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The credit option for CPU usage of a T2, T3, or T3a instance. Valid values are
                                                                                                                                                                                                                                                                                                                                    	// standard and unlimited.
                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                    	CpuCredits *string
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      The credit option for CPU usage of a T2, T3, or T3a instance.

                                                                                                                                                                                                                                                                                                                                      type CurrencyCodeValues

                                                                                                                                                                                                                                                                                                                                      type CurrencyCodeValues string
                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                      	CurrencyCodeValuesUsd CurrencyCodeValues = "USD"
                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                        Enum values for CurrencyCodeValues

                                                                                                                                                                                                                                                                                                                                        func (CurrencyCodeValues) Values

                                                                                                                                                                                                                                                                                                                                          Values returns all known values for CurrencyCodeValues. 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 CustomerGateway

                                                                                                                                                                                                                                                                                                                                          type CustomerGateway struct {
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The customer gateway's Border Gateway Protocol (BGP) Autonomous System Number
                                                                                                                                                                                                                                                                                                                                          	// (ASN).
                                                                                                                                                                                                                                                                                                                                          	BgpAsn *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) for the customer gateway certificate.
                                                                                                                                                                                                                                                                                                                                          	CertificateArn *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The ID of the customer gateway.
                                                                                                                                                                                                                                                                                                                                          	CustomerGatewayId *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The name of customer gateway device.
                                                                                                                                                                                                                                                                                                                                          	DeviceName *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Internet-routable IP address of the customer gateway's outside interface.
                                                                                                                                                                                                                                                                                                                                          	IpAddress *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The current state of the customer gateway (pending | available | deleting |
                                                                                                                                                                                                                                                                                                                                          	// deleted).
                                                                                                                                                                                                                                                                                                                                          	State *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// Any tags assigned to the customer gateway.
                                                                                                                                                                                                                                                                                                                                          	Tags []Tag
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The type of VPN connection the customer gateway supports (ipsec.1).
                                                                                                                                                                                                                                                                                                                                          	Type *string
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            Describes a customer gateway.

                                                                                                                                                                                                                                                                                                                                            type DatafeedSubscriptionState

                                                                                                                                                                                                                                                                                                                                            type DatafeedSubscriptionState string
                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                            	DatafeedSubscriptionStateActive   DatafeedSubscriptionState = "Active"
                                                                                                                                                                                                                                                                                                                                            	DatafeedSubscriptionStateInactive DatafeedSubscriptionState = "Inactive"
                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                              Enum values for DatafeedSubscriptionState

                                                                                                                                                                                                                                                                                                                                              func (DatafeedSubscriptionState) Values

                                                                                                                                                                                                                                                                                                                                                Values returns all known values for DatafeedSubscriptionState. 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 DefaultRouteTableAssociationValue

                                                                                                                                                                                                                                                                                                                                                type DefaultRouteTableAssociationValue string
                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                	DefaultRouteTableAssociationValueEnable  DefaultRouteTableAssociationValue = "enable"
                                                                                                                                                                                                                                                                                                                                                	DefaultRouteTableAssociationValueDisable DefaultRouteTableAssociationValue = "disable"
                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                  Enum values for DefaultRouteTableAssociationValue

                                                                                                                                                                                                                                                                                                                                                  func (DefaultRouteTableAssociationValue) Values

                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for DefaultRouteTableAssociationValue. 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 DefaultRouteTablePropagationValue

                                                                                                                                                                                                                                                                                                                                                    type DefaultRouteTablePropagationValue string
                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                    	DefaultRouteTablePropagationValueEnable  DefaultRouteTablePropagationValue = "enable"
                                                                                                                                                                                                                                                                                                                                                    	DefaultRouteTablePropagationValueDisable DefaultRouteTablePropagationValue = "disable"
                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                      Enum values for DefaultRouteTablePropagationValue

                                                                                                                                                                                                                                                                                                                                                      func (DefaultRouteTablePropagationValue) Values

                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for DefaultRouteTablePropagationValue. 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 DefaultTargetCapacityType

                                                                                                                                                                                                                                                                                                                                                        type DefaultTargetCapacityType string
                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                        	DefaultTargetCapacityTypeSpot     DefaultTargetCapacityType = "spot"
                                                                                                                                                                                                                                                                                                                                                        	DefaultTargetCapacityTypeOnDemand DefaultTargetCapacityType = "on-demand"
                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                          Enum values for DefaultTargetCapacityType

                                                                                                                                                                                                                                                                                                                                                          func (DefaultTargetCapacityType) Values

                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for DefaultTargetCapacityType. 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 DeleteFleetError

                                                                                                                                                                                                                                                                                                                                                            type DeleteFleetError struct {
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The error code.
                                                                                                                                                                                                                                                                                                                                                            	Code DeleteFleetErrorCode
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            	// The description for the error code.
                                                                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                              Describes an EC2 Fleet error.

                                                                                                                                                                                                                                                                                                                                                              type DeleteFleetErrorCode

                                                                                                                                                                                                                                                                                                                                                              type DeleteFleetErrorCode string
                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                              	DeleteFleetErrorCodeFleetIdDoesNotExist      DeleteFleetErrorCode = "fleetIdDoesNotExist"
                                                                                                                                                                                                                                                                                                                                                              	DeleteFleetErrorCodeFleetIdMalformed         DeleteFleetErrorCode = "fleetIdMalformed"
                                                                                                                                                                                                                                                                                                                                                              	DeleteFleetErrorCodeFleetNotInDeletableState DeleteFleetErrorCode = "fleetNotInDeletableState"
                                                                                                                                                                                                                                                                                                                                                              	DeleteFleetErrorCodeUnexpectedError          DeleteFleetErrorCode = "unexpectedError"
                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                Enum values for DeleteFleetErrorCode

                                                                                                                                                                                                                                                                                                                                                                func (DeleteFleetErrorCode) Values

                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for DeleteFleetErrorCode. 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 DeleteFleetErrorItem

                                                                                                                                                                                                                                                                                                                                                                  type DeleteFleetErrorItem struct {
                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                  	// The error.
                                                                                                                                                                                                                                                                                                                                                                  	Error *DeleteFleetError
                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                  	// The ID of the EC2 Fleet.
                                                                                                                                                                                                                                                                                                                                                                  	FleetId *string
                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                    Describes an EC2 Fleet that was not successfully deleted.

                                                                                                                                                                                                                                                                                                                                                                    type DeleteFleetSuccessItem

                                                                                                                                                                                                                                                                                                                                                                    type DeleteFleetSuccessItem struct {
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The current state of the EC2 Fleet.
                                                                                                                                                                                                                                                                                                                                                                    	CurrentFleetState FleetStateCode
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The ID of the EC2 Fleet.
                                                                                                                                                                                                                                                                                                                                                                    	FleetId *string
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The previous state of the EC2 Fleet.
                                                                                                                                                                                                                                                                                                                                                                    	PreviousFleetState FleetStateCode
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      Describes an EC2 Fleet that was successfully deleted.

                                                                                                                                                                                                                                                                                                                                                                      type DeleteLaunchTemplateVersionsResponseErrorItem

                                                                                                                                                                                                                                                                                                                                                                      type DeleteLaunchTemplateVersionsResponseErrorItem struct {
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The ID of the launch template.
                                                                                                                                                                                                                                                                                                                                                                      	LaunchTemplateId *string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The name of the launch template.
                                                                                                                                                                                                                                                                                                                                                                      	LaunchTemplateName *string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// Information about the error.
                                                                                                                                                                                                                                                                                                                                                                      	ResponseError *ResponseError
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The version number of the launch template.
                                                                                                                                                                                                                                                                                                                                                                      	VersionNumber int64
                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                        Describes a launch template version that could not be deleted.

                                                                                                                                                                                                                                                                                                                                                                        type DeleteLaunchTemplateVersionsResponseSuccessItem

                                                                                                                                                                                                                                                                                                                                                                        type DeleteLaunchTemplateVersionsResponseSuccessItem struct {
                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the launch template.
                                                                                                                                                                                                                                                                                                                                                                        	LaunchTemplateId *string
                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                        	// The name of the launch template.
                                                                                                                                                                                                                                                                                                                                                                        	LaunchTemplateName *string
                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                        	// The version number of the launch template.
                                                                                                                                                                                                                                                                                                                                                                        	VersionNumber int64
                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                          Describes a launch template version that was successfully deleted.

                                                                                                                                                                                                                                                                                                                                                                          type DeleteQueuedReservedInstancesError

                                                                                                                                                                                                                                                                                                                                                                          type DeleteQueuedReservedInstancesError struct {
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The error code.
                                                                                                                                                                                                                                                                                                                                                                          	Code DeleteQueuedReservedInstancesErrorCode
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The error message.
                                                                                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                            Describes the error for a Reserved Instance whose queued purchase could not be deleted.

                                                                                                                                                                                                                                                                                                                                                                            type DeleteQueuedReservedInstancesErrorCode

                                                                                                                                                                                                                                                                                                                                                                            type DeleteQueuedReservedInstancesErrorCode string
                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                            	DeleteQueuedReservedInstancesErrorCodeReservedInstancesIdInvalid        DeleteQueuedReservedInstancesErrorCode = "reserved-instances-id-invalid"
                                                                                                                                                                                                                                                                                                                                                                            	DeleteQueuedReservedInstancesErrorCodeReservedInstancesNotInQueuedState DeleteQueuedReservedInstancesErrorCode = "reserved-instances-not-in-queued-state"
                                                                                                                                                                                                                                                                                                                                                                            	DeleteQueuedReservedInstancesErrorCodeUnexpectedError                   DeleteQueuedReservedInstancesErrorCode = "unexpected-error"
                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                              Enum values for DeleteQueuedReservedInstancesErrorCode

                                                                                                                                                                                                                                                                                                                                                                              func (DeleteQueuedReservedInstancesErrorCode) Values

                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for DeleteQueuedReservedInstancesErrorCode. 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 DeregisterInstanceTagAttributeRequest

                                                                                                                                                                                                                                                                                                                                                                                type DeregisterInstanceTagAttributeRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// Indicates whether to deregister all tag keys in the current Region. Specify
                                                                                                                                                                                                                                                                                                                                                                                	// false to deregister all tag keys.
                                                                                                                                                                                                                                                                                                                                                                                	IncludeAllTagsOfInstance bool
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// Information about the tag keys to deregister.
                                                                                                                                                                                                                                                                                                                                                                                	InstanceTagKeys []string
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                  Information about the tag keys to deregister for the current Region. You can either specify individual tag keys or deregister all tag keys in the current Region. You must specify either IncludeAllTagsOfInstance or InstanceTagKeys in the request

                                                                                                                                                                                                                                                                                                                                                                                  type DescribeFastSnapshotRestoreSuccessItem

                                                                                                                                                                                                                                                                                                                                                                                  type DescribeFastSnapshotRestoreSuccessItem struct {
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The Availability Zone.
                                                                                                                                                                                                                                                                                                                                                                                  	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The time at which fast snapshot restores entered the disabled state.
                                                                                                                                                                                                                                                                                                                                                                                  	DisabledTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The time at which fast snapshot restores entered the disabling state.
                                                                                                                                                                                                                                                                                                                                                                                  	DisablingTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The time at which fast snapshot restores entered the enabled state.
                                                                                                                                                                                                                                                                                                                                                                                  	EnabledTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The time at which fast snapshot restores entered the enabling state.
                                                                                                                                                                                                                                                                                                                                                                                  	EnablingTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The time at which fast snapshot restores entered the optimizing state.
                                                                                                                                                                                                                                                                                                                                                                                  	OptimizingTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The AWS owner alias that enabled fast snapshot restores on the snapshot. This is
                                                                                                                                                                                                                                                                                                                                                                                  	// intended for future use.
                                                                                                                                                                                                                                                                                                                                                                                  	OwnerAlias *string
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The ID of the AWS account that enabled fast snapshot restores on the snapshot.
                                                                                                                                                                                                                                                                                                                                                                                  	OwnerId *string
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The ID of the snapshot.
                                                                                                                                                                                                                                                                                                                                                                                  	SnapshotId *string
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The state of fast snapshot restores.
                                                                                                                                                                                                                                                                                                                                                                                  	State FastSnapshotRestoreStateCode
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The reason for the state transition. The possible values are as follows:
                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                                                                                                                                  	// Client.UserInitiated - The state successfully transitioned to enabling or
                                                                                                                                                                                                                                                                                                                                                                                  	// disabling.
                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                  	// * Client.UserInitiated - Lifecycle state transition - The state
                                                                                                                                                                                                                                                                                                                                                                                  	// successfully transitioned to optimizing, enabled, or disabled.
                                                                                                                                                                                                                                                                                                                                                                                  	StateTransitionReason *string
                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                    Describes fast snapshot restores for a snapshot.

                                                                                                                                                                                                                                                                                                                                                                                    type DescribeFleetError

                                                                                                                                                                                                                                                                                                                                                                                    type DescribeFleetError struct {
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The error code that indicates why the instance could not be launched. For more
                                                                                                                                                                                                                                                                                                                                                                                    	// information about error codes, see Error Codes
                                                                                                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/errors-overview.html.html).
                                                                                                                                                                                                                                                                                                                                                                                    	ErrorCode *string
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The error message that describes why the instance could not be launched. For
                                                                                                                                                                                                                                                                                                                                                                                    	// more information about error messages, see Error Codes
                                                                                                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/errors-overview.html.html).
                                                                                                                                                                                                                                                                                                                                                                                    	ErrorMessage *string
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The launch templates and overrides that were used for launching the instances.
                                                                                                                                                                                                                                                                                                                                                                                    	// The values that you specify in the Overrides replace the values in the launch
                                                                                                                                                                                                                                                                                                                                                                                    	// template.
                                                                                                                                                                                                                                                                                                                                                                                    	LaunchTemplateAndOverrides *LaunchTemplateAndOverridesResponse
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// Indicates if the instance that could not be launched was a Spot Instance or
                                                                                                                                                                                                                                                                                                                                                                                    	// On-Demand Instance.
                                                                                                                                                                                                                                                                                                                                                                                    	Lifecycle InstanceLifecycle
                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                      Describes the instances that could not be launched by the fleet.

                                                                                                                                                                                                                                                                                                                                                                                      type DescribeFleetsInstances

                                                                                                                                                                                                                                                                                                                                                                                      type DescribeFleetsInstances struct {
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// The IDs of the instances.
                                                                                                                                                                                                                                                                                                                                                                                      	InstanceIds []string
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// The instance type.
                                                                                                                                                                                                                                                                                                                                                                                      	InstanceType InstanceType
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// The launch templates and overrides that were used for launching the instances.
                                                                                                                                                                                                                                                                                                                                                                                      	// The values that you specify in the Overrides replace the values in the launch
                                                                                                                                                                                                                                                                                                                                                                                      	// template.
                                                                                                                                                                                                                                                                                                                                                                                      	LaunchTemplateAndOverrides *LaunchTemplateAndOverridesResponse
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// Indicates if the instance that was launched is a Spot Instance or On-Demand
                                                                                                                                                                                                                                                                                                                                                                                      	// Instance.
                                                                                                                                                                                                                                                                                                                                                                                      	Lifecycle InstanceLifecycle
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// The value is Windows for Windows instances. Otherwise, the value is blank.
                                                                                                                                                                                                                                                                                                                                                                                      	Platform PlatformValues
                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                        Describes the instances that were launched by the fleet.

                                                                                                                                                                                                                                                                                                                                                                                        type DeviceType

                                                                                                                                                                                                                                                                                                                                                                                        type DeviceType string
                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                        	DeviceTypeEbs           DeviceType = "ebs"
                                                                                                                                                                                                                                                                                                                                                                                        	DeviceTypeInstanceStore DeviceType = "instance-store"
                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                          Enum values for DeviceType

                                                                                                                                                                                                                                                                                                                                                                                          func (DeviceType) Values

                                                                                                                                                                                                                                                                                                                                                                                          func (DeviceType) Values() []DeviceType

                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for DeviceType. 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 DhcpConfiguration

                                                                                                                                                                                                                                                                                                                                                                                            type DhcpConfiguration struct {
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// The name of a DHCP option.
                                                                                                                                                                                                                                                                                                                                                                                            	Key *string
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// One or more values for the DHCP option.
                                                                                                                                                                                                                                                                                                                                                                                            	Values []AttributeValue
                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                              Describes a DHCP configuration option.

                                                                                                                                                                                                                                                                                                                                                                                              type DhcpOptions

                                                                                                                                                                                                                                                                                                                                                                                              type DhcpOptions struct {
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// One or more DHCP options in the set.
                                                                                                                                                                                                                                                                                                                                                                                              	DhcpConfigurations []DhcpConfiguration
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// The ID of the set of DHCP options.
                                                                                                                                                                                                                                                                                                                                                                                              	DhcpOptionsId *string
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// The ID of the AWS account that owns the DHCP options set.
                                                                                                                                                                                                                                                                                                                                                                                              	OwnerId *string
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// Any tags assigned to the DHCP options set.
                                                                                                                                                                                                                                                                                                                                                                                              	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                Describes a set of DHCP options.

                                                                                                                                                                                                                                                                                                                                                                                                type DirectoryServiceAuthentication

                                                                                                                                                                                                                                                                                                                                                                                                type DirectoryServiceAuthentication struct {
                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                	// The ID of the Active Directory used for authentication.
                                                                                                                                                                                                                                                                                                                                                                                                	DirectoryId *string
                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                  Describes an Active Directory.

                                                                                                                                                                                                                                                                                                                                                                                                  type DirectoryServiceAuthenticationRequest

                                                                                                                                                                                                                                                                                                                                                                                                  type DirectoryServiceAuthenticationRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	// The ID of the Active Directory to be used for authentication.
                                                                                                                                                                                                                                                                                                                                                                                                  	DirectoryId *string
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    Describes the Active Directory to be used for client authentication.

                                                                                                                                                                                                                                                                                                                                                                                                    type DisableFastSnapshotRestoreErrorItem

                                                                                                                                                                                                                                                                                                                                                                                                    type DisableFastSnapshotRestoreErrorItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The errors.
                                                                                                                                                                                                                                                                                                                                                                                                    	FastSnapshotRestoreStateErrors []DisableFastSnapshotRestoreStateErrorItem
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The ID of the snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                    	SnapshotId *string
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      Contains information about the errors that occurred when disabling fast snapshot restores.

                                                                                                                                                                                                                                                                                                                                                                                                      type DisableFastSnapshotRestoreStateError

                                                                                                                                                                                                                                                                                                                                                                                                      type DisableFastSnapshotRestoreStateError struct {
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The error code.
                                                                                                                                                                                                                                                                                                                                                                                                      	Code *string
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The error message.
                                                                                                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                        Describes an error that occurred when disabling fast snapshot restores.

                                                                                                                                                                                                                                                                                                                                                                                                        type DisableFastSnapshotRestoreStateErrorItem

                                                                                                                                                                                                                                                                                                                                                                                                        type DisableFastSnapshotRestoreStateErrorItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        	// The Availability Zone.
                                                                                                                                                                                                                                                                                                                                                                                                        	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        	// The error.
                                                                                                                                                                                                                                                                                                                                                                                                        	Error *DisableFastSnapshotRestoreStateError
                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                          Contains information about an error that occurred when disabling fast snapshot restores.

                                                                                                                                                                                                                                                                                                                                                                                                          type DisableFastSnapshotRestoreSuccessItem

                                                                                                                                                                                                                                                                                                                                                                                                          type DisableFastSnapshotRestoreSuccessItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The Availability Zone.
                                                                                                                                                                                                                                                                                                                                                                                                          	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The time at which fast snapshot restores entered the disabled state.
                                                                                                                                                                                                                                                                                                                                                                                                          	DisabledTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The time at which fast snapshot restores entered the disabling state.
                                                                                                                                                                                                                                                                                                                                                                                                          	DisablingTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The time at which fast snapshot restores entered the enabled state.
                                                                                                                                                                                                                                                                                                                                                                                                          	EnabledTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The time at which fast snapshot restores entered the enabling state.
                                                                                                                                                                                                                                                                                                                                                                                                          	EnablingTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The time at which fast snapshot restores entered the optimizing state.
                                                                                                                                                                                                                                                                                                                                                                                                          	OptimizingTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The AWS owner alias that enabled fast snapshot restores on the snapshot. This is
                                                                                                                                                                                                                                                                                                                                                                                                          	// intended for future use.
                                                                                                                                                                                                                                                                                                                                                                                                          	OwnerAlias *string
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The ID of the AWS account that enabled fast snapshot restores on the snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                          	OwnerId *string
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The ID of the snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                          	SnapshotId *string
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The state of fast snapshot restores for the snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                          	State FastSnapshotRestoreStateCode
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The reason for the state transition. The possible values are as follows:
                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                          	// *
                                                                                                                                                                                                                                                                                                                                                                                                          	// Client.UserInitiated - The state successfully transitioned to enabling or
                                                                                                                                                                                                                                                                                                                                                                                                          	// disabling.
                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                          	// * Client.UserInitiated - Lifecycle state transition - The state
                                                                                                                                                                                                                                                                                                                                                                                                          	// successfully transitioned to optimizing, enabled, or disabled.
                                                                                                                                                                                                                                                                                                                                                                                                          	StateTransitionReason *string
                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                            Describes fast snapshot restores that were successfully disabled.

                                                                                                                                                                                                                                                                                                                                                                                                            type DiskImage

                                                                                                                                                                                                                                                                                                                                                                                                            type DiskImage struct {
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// A description of the disk image.
                                                                                                                                                                                                                                                                                                                                                                                                            	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// Information about the disk image.
                                                                                                                                                                                                                                                                                                                                                                                                            	Image *DiskImageDetail
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// Information about the volume.
                                                                                                                                                                                                                                                                                                                                                                                                            	Volume *VolumeDetail
                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                              Describes a disk image.

                                                                                                                                                                                                                                                                                                                                                                                                              type DiskImageDescription

                                                                                                                                                                                                                                                                                                                                                                                                              type DiskImageDescription struct {
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The checksum computed for the disk image.
                                                                                                                                                                                                                                                                                                                                                                                                              	Checksum *string
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The disk image format.
                                                                                                                                                                                                                                                                                                                                                                                                              	Format DiskImageFormat
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// A presigned URL for the import manifest stored in Amazon S3. For information
                                                                                                                                                                                                                                                                                                                                                                                                              	// about creating a presigned URL for an Amazon S3 object, read the "Query String
                                                                                                                                                                                                                                                                                                                                                                                                              	// Request Authentication Alternative" section of the Authenticating REST Requests
                                                                                                                                                                                                                                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html) topic
                                                                                                                                                                                                                                                                                                                                                                                                              	// in the Amazon Simple Storage Service Developer Guide. For information about the
                                                                                                                                                                                                                                                                                                                                                                                                              	// import manifest referenced by this API action, see VM Import Manifest
                                                                                                                                                                                                                                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html).
                                                                                                                                                                                                                                                                                                                                                                                                              	ImportManifestUrl *string
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The size of the disk image, in GiB.
                                                                                                                                                                                                                                                                                                                                                                                                              	Size int64
                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                Describes a disk image.

                                                                                                                                                                                                                                                                                                                                                                                                                type DiskImageDetail

                                                                                                                                                                                                                                                                                                                                                                                                                type DiskImageDetail struct {
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// The size of the disk image, in GiB.
                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                	Bytes int64
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// The disk image format.
                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                	Format DiskImageFormat
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// A presigned URL for the import manifest stored in Amazon S3 and presented here
                                                                                                                                                                                                                                                                                                                                                                                                                	// as an Amazon S3 presigned URL. For information about creating a presigned URL
                                                                                                                                                                                                                                                                                                                                                                                                                	// for an Amazon S3 object, read the "Query String Request Authentication
                                                                                                                                                                                                                                                                                                                                                                                                                	// Alternative" section of the Authenticating REST Requests
                                                                                                                                                                                                                                                                                                                                                                                                                	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html) topic
                                                                                                                                                                                                                                                                                                                                                                                                                	// in the Amazon Simple Storage Service Developer Guide. For information about the
                                                                                                                                                                                                                                                                                                                                                                                                                	// import manifest referenced by this API action, see VM Import Manifest
                                                                                                                                                                                                                                                                                                                                                                                                                	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html).
                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                	ImportManifestUrl *string
                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                  Describes a disk image.

                                                                                                                                                                                                                                                                                                                                                                                                                  type DiskImageFormat

                                                                                                                                                                                                                                                                                                                                                                                                                  type DiskImageFormat string
                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                  	DiskImageFormatVmdk DiskImageFormat = "VMDK"
                                                                                                                                                                                                                                                                                                                                                                                                                  	DiskImageFormatRaw  DiskImageFormat = "RAW"
                                                                                                                                                                                                                                                                                                                                                                                                                  	DiskImageFormatVhd  DiskImageFormat = "VHD"
                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for DiskImageFormat

                                                                                                                                                                                                                                                                                                                                                                                                                    func (DiskImageFormat) Values

                                                                                                                                                                                                                                                                                                                                                                                                                    func (DiskImageFormat) Values() []DiskImageFormat

                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for DiskImageFormat. 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 DiskImageVolumeDescription

                                                                                                                                                                                                                                                                                                                                                                                                                      type DiskImageVolumeDescription struct {
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// The volume identifier.
                                                                                                                                                                                                                                                                                                                                                                                                                      	Id *string
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// The size of the volume, in GiB.
                                                                                                                                                                                                                                                                                                                                                                                                                      	Size int64
                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                        Describes a disk image volume.

                                                                                                                                                                                                                                                                                                                                                                                                                        type DiskInfo

                                                                                                                                                                                                                                                                                                                                                                                                                        type DiskInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                        	// The number of disks with this configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                        	Count *int32
                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                        	// The size of the disk in GB.
                                                                                                                                                                                                                                                                                                                                                                                                                        	SizeInGB *int64
                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                        	// The type of disk.
                                                                                                                                                                                                                                                                                                                                                                                                                        	Type DiskType
                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                          Describes the disk.

                                                                                                                                                                                                                                                                                                                                                                                                                          type DiskType

                                                                                                                                                                                                                                                                                                                                                                                                                          type DiskType string
                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                          	DiskTypeHdd DiskType = "hdd"
                                                                                                                                                                                                                                                                                                                                                                                                                          	DiskTypeSsd DiskType = "ssd"
                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for DiskType

                                                                                                                                                                                                                                                                                                                                                                                                                            func (DiskType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                            func (DiskType) Values() []DiskType

                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for DiskType. 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 DnsEntry

                                                                                                                                                                                                                                                                                                                                                                                                                              type DnsEntry struct {
                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                              	// The DNS name.
                                                                                                                                                                                                                                                                                                                                                                                                                              	DnsName *string
                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                              	// The ID of the private hosted zone.
                                                                                                                                                                                                                                                                                                                                                                                                                              	HostedZoneId *string
                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                Describes a DNS entry.

                                                                                                                                                                                                                                                                                                                                                                                                                                type DnsNameState

                                                                                                                                                                                                                                                                                                                                                                                                                                type DnsNameState string
                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                	DnsNameStatePendingVerification DnsNameState = "pendingVerification"
                                                                                                                                                                                                                                                                                                                                                                                                                                	DnsNameStateVerified            DnsNameState = "verified"
                                                                                                                                                                                                                                                                                                                                                                                                                                	DnsNameStateFailed              DnsNameState = "failed"
                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for DnsNameState

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (DnsNameState) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (DnsNameState) Values() []DnsNameState

                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for DnsNameState. 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 DnsServersOptionsModifyStructure

                                                                                                                                                                                                                                                                                                                                                                                                                                    type DnsServersOptionsModifyStructure struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The IPv4 address range, in CIDR notation, of the DNS servers to be used. You can
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// specify up to two DNS servers. Ensure that the DNS servers can be reached by the
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// clients. The specified values overwrite the existing values.
                                                                                                                                                                                                                                                                                                                                                                                                                                    	CustomDnsServers []string
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Indicates whether DNS servers should be used. Specify False to delete the
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// existing DNS servers.
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Enabled bool
                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                      Information about the DNS server to be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                      type DnsSupportValue

                                                                                                                                                                                                                                                                                                                                                                                                                                      type DnsSupportValue string
                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                      	DnsSupportValueEnable  DnsSupportValue = "enable"
                                                                                                                                                                                                                                                                                                                                                                                                                                      	DnsSupportValueDisable DnsSupportValue = "disable"
                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for DnsSupportValue

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (DnsSupportValue) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (DnsSupportValue) Values() []DnsSupportValue

                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for DnsSupportValue. 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 DomainType

                                                                                                                                                                                                                                                                                                                                                                                                                                          type DomainType string
                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                          	DomainTypeVpc      DomainType = "vpc"
                                                                                                                                                                                                                                                                                                                                                                                                                                          	DomainTypeStandard DomainType = "standard"
                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for DomainType

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (DomainType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (DomainType) Values() []DomainType

                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for DomainType. 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 EbsBlockDevice

                                                                                                                                                                                                                                                                                                                                                                                                                                              type EbsBlockDevice struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Indicates whether the EBS volume is deleted on instance termination. For more
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// information, see Preserving Amazon EBS volumes on instance termination
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#preserving-volumes-on-termination)
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// in the Amazon EC2 User Guide.
                                                                                                                                                                                                                                                                                                                                                                                                                                              	DeleteOnTermination bool
                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Indicates whether the encryption state of an EBS volume is changed while being
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// restored from a backing snapshot. The effect of setting the encryption state to
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// true depends on the volume origin (new or from a snapshot), starting encryption
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// state, ownership, and whether encryption by default is enabled. For more
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// information, see Amazon EBS encryption
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-parameters)
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// in the Amazon EC2 User Guide. In no case can you remove encryption from an
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// encrypted volume. Encrypted volumes can only be attached to instances that
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// support Amazon EBS encryption. For more information, see Supported instance
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// types
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances).
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This parameter is not returned by .
                                                                                                                                                                                                                                                                                                                                                                                                                                              	Encrypted bool
                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The number of I/O operations per second (IOPS). For gp3, io1, and io2 volumes,
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// this represents the number of IOPS that are provisioned for the volume. For gp2
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// volumes, this represents the baseline performance of the volume and the rate at
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// which the volume accumulates I/O credits for bursting. The following are the
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// supported values for each volume type:
                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// * gp3: 3,000-16,000 IOPS
                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// * io1:
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// 100-64,000 IOPS
                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// * io2: 100-64,000 IOPS
                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// For io1 and io2 volumes, we guarantee
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// 64,000 IOPS only for Instances built on the Nitro System
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances).
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Other instance families guarantee performance up to 32,000 IOPS. This parameter
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// is required for io1 and io2 volumes. The default for gp3 volumes is 3,000 IOPS.
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This parameter is not supported for gp2, st1, sc1, or standard volumes.
                                                                                                                                                                                                                                                                                                                                                                                                                                              	Iops int32
                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// under which the EBS volume is encrypted. This parameter is only supported on
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// BlockDeviceMapping objects called by RunInstances
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html),
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// RequestSpotFleet
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RequestSpotFleet.html),
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// and RequestSpotInstances
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RequestSpotInstances.html).
                                                                                                                                                                                                                                                                                                                                                                                                                                              	KmsKeyId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The ID of the snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                                                              	SnapshotId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The throughput that the volume supports, in MiB/s. This parameter is valid only
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// for gp3 volumes. Valid Range: Minimum value of 125. Maximum value of 1000.
                                                                                                                                                                                                                                                                                                                                                                                                                                              	Throughput int32
                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The size of the volume, in GiBs. You must specify either a snapshot ID or a
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// volume size. If you specify a snapshot, the default is the snapshot size. You
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// can specify a volume size that is equal to or larger than the snapshot size. The
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// following are the supported volumes sizes for each volume type:
                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// * gp2 and
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// gp3:1-16,384
                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// * io1 and io2: 4-16,384
                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// * st1 and sc1: 125-16,384
                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// * standard:
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// 1-1,024
                                                                                                                                                                                                                                                                                                                                                                                                                                              	VolumeSize int32
                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The volume type. For more information, see Amazon EBS volume types
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html) in the
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Amazon EC2 User Guide. If the volume type is io1 or io2, you must specify the
                                                                                                                                                                                                                                                                                                                                                                                                                                              	// IOPS that the volume supports.
                                                                                                                                                                                                                                                                                                                                                                                                                                              	VolumeType VolumeType
                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                Describes a block device for an EBS volume.

                                                                                                                                                                                                                                                                                                                                                                                                                                                type EbsEncryptionSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                type EbsEncryptionSupport string
                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                	EbsEncryptionSupportUnsupported EbsEncryptionSupport = "unsupported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                	EbsEncryptionSupportSupported   EbsEncryptionSupport = "supported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for EbsEncryptionSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (EbsEncryptionSupport) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for EbsEncryptionSupport. 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 EbsInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EbsInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Describes the optimized EBS performance for the instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EbsOptimizedInfo *EbsOptimizedInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Indicates whether the instance type is Amazon EBS-optimized. For more
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// information, see Amazon EBS-optimized instances
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSOptimized.html) in
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Amazon EC2 User Guide.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EbsOptimizedSupport EbsOptimizedSupport
                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Indicates whether Amazon EBS encryption is supported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EncryptionSupport EbsEncryptionSupport
                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Indicates whether non-volatile memory express (NVMe) is supported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	NvmeSupport EbsNvmeSupport
                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Describes the Amazon EBS features supported by the instance type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EbsInstanceBlockDevice

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EbsInstanceBlockDevice struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The time stamp when the attachment initiated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	AttachTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Indicates whether the volume is deleted on instance termination.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DeleteOnTermination bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The attachment state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Status AttachmentStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ID of the EBS volume.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	VolumeId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Describes a parameter used to set up an EBS volume in a block device mapping.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EbsInstanceBlockDeviceSpecification

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EbsInstanceBlockDeviceSpecification struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Indicates whether the volume is deleted on instance termination.
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	DeleteOnTermination bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the EBS volume.
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	VolumeId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Describes information used to set up an EBS volume specified in a block device mapping.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EbsNvmeSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EbsNvmeSupport string
                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	EbsNvmeSupportUnsupported EbsNvmeSupport = "unsupported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	EbsNvmeSupportSupported   EbsNvmeSupport = "supported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	EbsNvmeSupportRequired    EbsNvmeSupport = "required"
                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for EbsNvmeSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (EbsNvmeSupport) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (EbsNvmeSupport) Values() []EbsNvmeSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for EbsNvmeSupport. 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 EbsOptimizedInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type EbsOptimizedInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The baseline bandwidth performance for an EBS-optimized instance type, in Mbps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BaselineBandwidthInMbps *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The baseline input/output storage operations per seconds for an EBS-optimized
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BaselineIops *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The baseline throughput performance for an EBS-optimized instance type, in MB/s.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BaselineThroughputInMBps *float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The maximum bandwidth performance for an EBS-optimized instance type, in Mbps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	MaximumBandwidthInMbps *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The maximum input/output storage operations per second for an EBS-optimized
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	MaximumIops *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The maximum throughput performance for an EBS-optimized instance type, in MB/s.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	MaximumThroughputInMBps *float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Describes the optimized EBS performance for supported instance types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EbsOptimizedSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EbsOptimizedSupport string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	EbsOptimizedSupportUnsupported EbsOptimizedSupport = "unsupported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	EbsOptimizedSupportSupported   EbsOptimizedSupport = "supported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	EbsOptimizedSupportDefault     EbsOptimizedSupport = "default"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for EbsOptimizedSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (EbsOptimizedSupport) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for EbsOptimizedSupport. 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 EgressOnlyInternetGateway

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EgressOnlyInternetGateway struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Information about the attachment of the egress-only internet gateway.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Attachments []InternetGatewayAttachment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The ID of the egress-only internet gateway.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EgressOnlyInternetGatewayId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The tags assigned to the egress-only internet gateway.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Describes an egress-only internet gateway.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ElasticGpuAssociation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ElasticGpuAssociation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ID of the association.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ElasticGpuAssociationId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The state of the association between the instance and the Elastic Graphics
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ElasticGpuAssociationState *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The time the Elastic Graphics accelerator was associated with the instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ElasticGpuAssociationTime *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ID of the Elastic Graphics accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ElasticGpuId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Describes the association between an instance and an Elastic Graphics accelerator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ElasticGpuHealth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ElasticGpuHealth struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The health status.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Status ElasticGpuStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Describes the status of an Elastic Graphics accelerator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ElasticGpuSpecification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ElasticGpuSpecification struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The type of Elastic Graphics accelerator. For more information about the values
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// to specify for Type, see Elastic Graphics Basics
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/elastic-graphics.html#elastic-graphics-basics),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// specifically the Elastic Graphics accelerator column, in the Amazon Elastic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Compute Cloud User Guide for Windows Instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Type *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A specification for an Elastic Graphics accelerator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ElasticGpuSpecificationResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ElasticGpuSpecificationResponse struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The elastic GPU type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Type *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Describes an elastic GPU.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ElasticGpuState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ElasticGpuState string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ElasticGpuStateAttached ElasticGpuState = "ATTACHED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for ElasticGpuState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (ElasticGpuState) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (ElasticGpuState) Values() []ElasticGpuState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for ElasticGpuState. 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 ElasticGpuStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ElasticGpuStatus string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ElasticGpuStatusOk       ElasticGpuStatus = "OK"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ElasticGpuStatusImpaired ElasticGpuStatus = "IMPAIRED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for ElasticGpuStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (ElasticGpuStatus) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for ElasticGpuStatus. 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 ElasticGpus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ElasticGpus struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The Availability Zone in the which the Elastic Graphics accelerator resides.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The status of the Elastic Graphics accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ElasticGpuHealth *ElasticGpuHealth
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ID of the Elastic Graphics accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ElasticGpuId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The state of the Elastic Graphics accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ElasticGpuState ElasticGpuState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The type of Elastic Graphics accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ElasticGpuType *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ID of the instance to which the Elastic Graphics accelerator is attached.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	InstanceId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The tags assigned to the Elastic Graphics accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Describes an Elastic Graphics accelerator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ElasticInferenceAccelerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ElasticInferenceAccelerator struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The type of elastic inference accelerator. The possible values are eia1.medium,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// eia1.large, eia1.xlarge, eia2.medium, eia2.large, and eia2.xlarge.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Type *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The number of elastic inference accelerators to attach to the instance. Default:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Count int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Describes an elastic inference accelerator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ElasticInferenceAcceleratorAssociation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ElasticInferenceAcceleratorAssociation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the elastic inference accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ElasticInferenceAcceleratorArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The ID of the association.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ElasticInferenceAcceleratorAssociationId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The state of the elastic inference accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ElasticInferenceAcceleratorAssociationState *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The time at which the elastic inference accelerator is associated with an
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ElasticInferenceAcceleratorAssociationTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Describes the association between an instance and an elastic inference accelerator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EnaSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EnaSupport string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	EnaSupportUnsupported EnaSupport = "unsupported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	EnaSupportSupported   EnaSupport = "supported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	EnaSupportRequired    EnaSupport = "required"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for EnaSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (EnaSupport) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (EnaSupport) Values() []EnaSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for EnaSupport. 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 EnableFastSnapshotRestoreErrorItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EnableFastSnapshotRestoreErrorItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The errors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	FastSnapshotRestoreStateErrors []EnableFastSnapshotRestoreStateErrorItem
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The ID of the snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SnapshotId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Contains information about the errors that occurred when enabling fast snapshot restores.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EnableFastSnapshotRestoreStateError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EnableFastSnapshotRestoreStateError struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The error code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Code *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The error message.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Describes an error that occurred when enabling fast snapshot restores.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EnableFastSnapshotRestoreStateErrorItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EnableFastSnapshotRestoreStateErrorItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The Availability Zone.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The error.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Error *EnableFastSnapshotRestoreStateError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Contains information about an error that occurred when enabling fast snapshot restores.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EnableFastSnapshotRestoreSuccessItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EnableFastSnapshotRestoreSuccessItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The Availability Zone.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The time at which fast snapshot restores entered the disabled state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DisabledTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The time at which fast snapshot restores entered the disabling state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DisablingTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The time at which fast snapshot restores entered the enabled state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	EnabledTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The time at which fast snapshot restores entered the enabling state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	EnablingTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The time at which fast snapshot restores entered the optimizing state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	OptimizingTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The AWS owner alias that enabled fast snapshot restores on the snapshot. This is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// intended for future use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	OwnerAlias *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ID of the AWS account that enabled fast snapshot restores on the snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	OwnerId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ID of the snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	SnapshotId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The state of fast snapshot restores.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	State FastSnapshotRestoreStateCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The reason for the state transition. The possible values are as follows:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Client.UserInitiated - The state successfully transitioned to enabling or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// disabling.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// * Client.UserInitiated - Lifecycle state transition - The state
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// successfully transitioned to optimizing, enabled, or disabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	StateTransitionReason *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Describes fast snapshot restores that were successfully enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EnclaveOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EnclaveOptions struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// If this parameter is set to true, the instance is enabled for AWS Nitro
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Enclaves; otherwise, it is not enabled for AWS Nitro Enclaves.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Enabled bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Indicates whether the instance is enabled for AWS Nitro Enclaves.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EnclaveOptionsRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EnclaveOptionsRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// To enable the instance for AWS Nitro Enclaves, set this parameter to true.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Enabled bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Indicates whether the instance is enabled for AWS Nitro Enclaves. For more information, see What is AWS Nitro Enclaves? (https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave.html) in the AWS Nitro Enclaves User Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EndDateType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EndDateType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	EndDateTypeUnlimited EndDateType = "unlimited"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	EndDateTypeLimited   EndDateType = "limited"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for EndDateType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (EndDateType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (EndDateType) Values() []EndDateType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for EndDateType. 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 EphemeralNvmeSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EphemeralNvmeSupport string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	EphemeralNvmeSupportUnsupported EphemeralNvmeSupport = "unsupported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	EphemeralNvmeSupportSupported   EphemeralNvmeSupport = "supported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	EphemeralNvmeSupportRequired    EphemeralNvmeSupport = "required"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for EphemeralNvmeSupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (EphemeralNvmeSupport) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for EphemeralNvmeSupport. 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 EventCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EventCode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EventCodeInstanceReboot     EventCode = "instance-reboot"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EventCodeSystemReboot       EventCode = "system-reboot"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EventCodeSystemMaintenance  EventCode = "system-maintenance"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EventCodeInstanceRetirement EventCode = "instance-retirement"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EventCodeInstanceStop       EventCode = "instance-stop"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for EventCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (EventCode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (EventCode) Values() []EventCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for EventCode. 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 EventInformation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EventInformation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The description of the event.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	EventDescription *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The event. The following are the error events:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * iamFleetRoleInvalid - The EC2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Fleet or Spot Fleet did not have the required permissions either to launch or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// terminate an instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * spotFleetRequestConfigurationInvalid - The
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// configuration is not valid. For more information, see the description of the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// event.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * spotInstanceCountLimitExceeded - You've reached the limit on the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// number of Spot Instances that you can launch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The following are the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// fleetRequestChange events:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * active - The EC2 Fleet or Spot Fleet request has
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// been validated and Amazon EC2 is attempting to maintain the target number of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// running Spot Instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * cancelled - The EC2 Fleet or Spot Fleet request is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// canceled and has no running Spot Instances. The EC2 Fleet or Spot Fleet will be
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// deleted two days after its instances were terminated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * cancelled_running - The
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// EC2 Fleet or Spot Fleet request is canceled and does not launch additional Spot
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Instances. Existing Spot Instances continue to run until they are interrupted or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// terminated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * cancelled_terminating - The EC2 Fleet or Spot Fleet request is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// canceled and its Spot Instances are terminating.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * expired - The EC2 Fleet or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Spot Fleet request has expired. A subsequent event indicates that the instances
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// were terminated, if the request was created with
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// TerminateInstancesWithExpiration set.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * modify_in_progress - A request to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// modify the EC2 Fleet or Spot Fleet request was accepted and is in progress.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// modify_successful - The EC2 Fleet or Spot Fleet request was modified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// price_update - The price for a launch configuration was adjusted because it was
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// too high. This change is permanent.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * submitted - The EC2 Fleet or Spot Fleet
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// request is being evaluated and Amazon EC2 is preparing to launch the target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// number of Spot Instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The following are the instanceChange events:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// launched - A request was fulfilled and a new instance was launched.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// terminated - An instance was terminated by the user.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The following are the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Information events:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * launchSpecTemporarilyBlacklisted - The configuration is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// not valid and several attempts to launch instances have failed. For more
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// information, see the description of the event.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * launchSpecUnusable - The price
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// in a launch specification is not valid because it is below the Spot price or the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Spot price is above the On-Demand price.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * fleetProgressHalted - The price in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// every launch specification is not valid. A launch specification might become
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// valid if the Spot price changes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	EventSubType *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the instance. This information is available only for instanceChange
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// events.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	InstanceId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Describes an EC2 Fleet or Spot Fleet event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EventType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EventType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	EventTypeInstanceChange EventType = "instanceChange"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	EventTypeBatchChange    EventType = "fleetRequestChange"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	EventTypeError          EventType = "error"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	EventTypeInformation    EventType = "information"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for EventType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (EventType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (EventType) Values() []EventType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for EventType. 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 ExcessCapacityTerminationPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ExcessCapacityTerminationPolicy string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ExcessCapacityTerminationPolicyNoTermination ExcessCapacityTerminationPolicy = "noTermination"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ExcessCapacityTerminationPolicyDefault       ExcessCapacityTerminationPolicy = "default"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for ExcessCapacityTerminationPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (ExcessCapacityTerminationPolicy) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for ExcessCapacityTerminationPolicy. 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 Explanation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Explanation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The network ACL.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Acl *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The network ACL rule.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AclRule *AnalysisAclRule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The IPv4 address, in CIDR notation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Address *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The IPv4 addresses, in CIDR notation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Addresses []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The resource to which the component is attached.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AttachedTo *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The Availability Zones.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AvailabilityZones []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The CIDR ranges.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Cidrs []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The listener for a Classic Load Balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ClassicLoadBalancerListener *AnalysisLoadBalancerListener
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The component.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Component *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The customer gateway.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	CustomerGateway *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The destination.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Destination *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The destination VPC.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	DestinationVpc *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The direction. The following are possible values:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// * egress
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// * ingress
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Direction *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The load balancer listener.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ElasticLoadBalancerListener *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The explanation code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ExplanationCode *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The route table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	IngressRouteTable *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The internet gateway.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	InternetGateway *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	LoadBalancerArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The listener port of the load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	LoadBalancerListenerPort int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The target.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	LoadBalancerTarget *AnalysisLoadBalancerTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The target group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	LoadBalancerTargetGroup *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The target groups.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	LoadBalancerTargetGroups []AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The target port.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	LoadBalancerTargetPort int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The missing component.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MissingComponent *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The NAT gateway.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	NatGateway *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The network interface.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	NetworkInterface *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The packet field.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	PacketField *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The port.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Port int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The port ranges.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	PortRanges []PortRange
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The prefix list.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	PrefixList *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The protocols.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Protocols []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The route table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RouteTable *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The route table route.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RouteTableRoute *AnalysisRouteTableRoute
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The security group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SecurityGroup *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The security group rule.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SecurityGroupRule *AnalysisSecurityGroupRule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The security groups.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SecurityGroups []AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The source VPC.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SourceVpc *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	State *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The subnet.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Subnet *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The route table for the subnet.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SubnetRouteTable *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The component VPC.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Vpc *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The VPC endpoint.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	VpcEndpoint *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The VPC peering connection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	VpcPeeringConnection *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The VPN connection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	VpnConnection *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The VPN gateway.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	VpnGateway *AnalysisComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Describes an explanation code for an unreachable path. For more information, see Reachability Analyzer explanation codes (https://docs.aws.amazon.com/vpc/latest/reachability/explanation-codes.html).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ExportEnvironment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ExportEnvironment string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ExportEnvironmentCitrix    ExportEnvironment = "citrix"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ExportEnvironmentVmware    ExportEnvironment = "vmware"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ExportEnvironmentMicrosoft ExportEnvironment = "microsoft"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for ExportEnvironment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (ExportEnvironment) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for ExportEnvironment. 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 ExportImageTask

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ExportImageTask struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// A description of the image being exported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the export image task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ExportImageTaskId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the image.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ImageId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The percent complete of the export image task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Progress *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Information about the destination Amazon S3 bucket.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	S3ExportLocation *ExportTaskS3Location
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The status of the export image task. The possible values are active, completed,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// deleting, and deleted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Status *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The status message for the export image task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	StatusMessage *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Any tags assigned to the image being exported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Describes an export image task.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ExportTask

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ExportTask struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A description of the resource being exported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The ID of the export task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ExportTaskId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Information about the export task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ExportToS3Task *ExportToS3Task
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Information about the instance to export.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	InstanceExportDetails *InstanceExportDetails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The state of the export task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	State ExportTaskState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The status message related to the export task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	StatusMessage *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The tags for the export task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Describes an instance export task.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ExportTaskS3Location

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ExportTaskS3Location struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The destination Amazon S3 bucket.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	S3Bucket *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The prefix (logical hierarchy) in the bucket.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	S3Prefix *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Describes the destination for an export image task.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ExportTaskS3LocationRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ExportTaskS3LocationRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The destination Amazon S3 bucket.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	S3Bucket *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The prefix (logical hierarchy) in the bucket.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	S3Prefix *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Describes the destination for an export image task.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ExportTaskState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ExportTaskState string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ExportTaskStateActive     ExportTaskState = "active"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ExportTaskStateCancelling ExportTaskState = "cancelling"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ExportTaskStateCancelled  ExportTaskState = "cancelled"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ExportTaskStateCompleted  ExportTaskState = "completed"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for ExportTaskState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (ExportTaskState) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (ExportTaskState) Values() []ExportTaskState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for ExportTaskState. 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 ExportToS3Task

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ExportToS3Task struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The container format used to combine disk images with metadata (such as OVF). If
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// absent, only the disk image is exported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ContainerFormat ContainerFormat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The format for the exported image.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	DiskImageFormat DiskImageFormat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The Amazon S3 bucket for the destination image. The destination bucket must
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// exist and grant WRITE and READ_ACP permissions to the AWS account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// vm-import-export@amazon.com.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	S3Bucket *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The encryption key for your S3 bucket.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	S3Key *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Describes the format and location for an instance export task.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ExportToS3TaskSpecification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ExportToS3TaskSpecification struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The container format used to combine disk images with metadata (such as OVF). If
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// absent, only the disk image is exported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ContainerFormat ContainerFormat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The format for the exported image.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DiskImageFormat DiskImageFormat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The Amazon S3 bucket for the destination image. The destination bucket must
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// exist and grant WRITE and READ_ACP permissions to the AWS account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// vm-import-export@amazon.com.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	S3Bucket *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The image is written to a single object in the Amazon S3 bucket at the S3 key
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// s3prefix + exportTaskId + '.' + diskImageFormat.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	S3Prefix *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Describes an instance export task.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FailedQueuedPurchaseDeletion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FailedQueuedPurchaseDeletion struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The error.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Error *DeleteQueuedReservedInstancesError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the Reserved Instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ReservedInstancesId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Describes a Reserved Instance whose queued purchase was not deleted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FastSnapshotRestoreStateCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FastSnapshotRestoreStateCode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	FastSnapshotRestoreStateCodeEnabling   FastSnapshotRestoreStateCode = "enabling"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	FastSnapshotRestoreStateCodeOptimizing FastSnapshotRestoreStateCode = "optimizing"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	FastSnapshotRestoreStateCodeEnabled    FastSnapshotRestoreStateCode = "enabled"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	FastSnapshotRestoreStateCodeDisabling  FastSnapshotRestoreStateCode = "disabling"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	FastSnapshotRestoreStateCodeDisabled   FastSnapshotRestoreStateCode = "disabled"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for FastSnapshotRestoreStateCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (FastSnapshotRestoreStateCode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for FastSnapshotRestoreStateCode. 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 FederatedAuthentication

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FederatedAuthentication struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the IAM SAML identity provider.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	SamlProviderArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the IAM SAML identity provider for the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// self-service portal.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	SelfServiceSamlProviderArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Describes the IAM SAML identity providers used for federated authentication.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FederatedAuthenticationRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FederatedAuthenticationRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The Amazon Resource Name (ARN) of the IAM SAML identity provider.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SAMLProviderArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The Amazon Resource Name (ARN) of the IAM SAML identity provider for the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// self-service portal.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SelfServiceSAMLProviderArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The IAM SAML identity provider used for federated authentication.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Filter struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the filter. Filter names are case-sensitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The filter values. Filter values are case-sensitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Values []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A filter name and value pair that is used to return a more specific list of results from a describe operation. Filters can be used to match a set of resources by specific criteria, such as tags, attributes, or IDs. The filters supported by a describe operation are documented with the describe operation. For example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * DescribeAvailabilityZones

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * DescribeImages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * DescribeInstances

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * DescribeKeyPairs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * DescribeSecurityGroups

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * DescribeSnapshots

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * DescribeSubnets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * DescribeTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * DescribeVolumes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * DescribeVpcs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FleetActivityStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FleetActivityStatus string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FleetActivityStatusError              FleetActivityStatus = "error"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FleetActivityStatusPendingFulfillment FleetActivityStatus = "pending_fulfillment"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FleetActivityStatusPendingTermination FleetActivityStatus = "pending_termination"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FleetActivityStatusFulfilled          FleetActivityStatus = "fulfilled"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for FleetActivityStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (FleetActivityStatus) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for FleetActivityStatus. 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 FleetCapacityReservationUsageStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FleetCapacityReservationUsageStrategy string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FleetCapacityReservationUsageStrategyUseCapacityReservationsFirst FleetCapacityReservationUsageStrategy = "use-capacity-reservations-first"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for FleetCapacityReservationUsageStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (FleetCapacityReservationUsageStrategy) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for FleetCapacityReservationUsageStrategy. 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 FleetData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FleetData struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The progress of the EC2 Fleet. If there is an error, the status is error. After
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// all requests are placed, the status is pending_fulfillment. If the size of the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// EC2 Fleet is equal to or greater than its target capacity, the status is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// fulfilled. If the size of the EC2 Fleet is decreased, the status is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// pending_termination while instances are terminating.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ActivityStatus FleetActivityStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// the request. For more information, see Ensuring Idempotency
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Constraints: Maximum 64 ASCII characters
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ClientToken *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The creation date and time of the EC2 Fleet.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CreateTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Information about the instances that could not be launched by the fleet. Valid
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// only when Type is set to instant.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Errors []DescribeFleetError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Indicates whether running instances should be terminated if the target capacity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// of the EC2 Fleet is decreased below the current size of the EC2 Fleet.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ExcessCapacityTerminationPolicy FleetExcessCapacityTerminationPolicy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The ID of the EC2 Fleet.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FleetId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The state of the EC2 Fleet.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FleetState FleetStateCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The number of units fulfilled by this request compared to the set target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// capacity.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FulfilledCapacity float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The number of units fulfilled by this request compared to the set target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// On-Demand capacity.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FulfilledOnDemandCapacity float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Information about the instances that were launched by the fleet. Valid only when
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Type is set to instant.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Instances []DescribeFleetsInstances
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The launch template and overrides.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	LaunchTemplateConfigs []FleetLaunchTemplateConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The allocation strategy of On-Demand Instances in an EC2 Fleet.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	OnDemandOptions *OnDemandOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Indicates whether EC2 Fleet should replace unhealthy instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ReplaceUnhealthyInstances bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The configuration of Spot Instances in an EC2 Fleet.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	SpotOptions *SpotOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The tags for an EC2 Fleet resource.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The number of units to request. You can choose to set the target capacity in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// terms of instances or a performance characteristic that is important to your
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// application workload, such as vCPUs, memory, or I/O. If the request type is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// maintain, you can specify a target capacity of 0 and add capacity later.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TargetCapacitySpecification *TargetCapacitySpecification
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Indicates whether running instances should be terminated when the EC2 Fleet
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// expires.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TerminateInstancesWithExpiration bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The type of request. Indicates whether the EC2 Fleet only requests the target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// capacity, or also attempts to maintain it. If you request a certain target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// capacity, EC2 Fleet only places the required requests; it does not attempt to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// replenish instances if capacity is diminished, and it does not submit requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// in alternative capacity pools if capacity is unavailable. To maintain a certain
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// target capacity, EC2 Fleet places the required requests to meet this target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// capacity. It also automatically replenishes any interrupted Spot Instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Default: maintain.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Type FleetType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The start date and time of the request, in UTC format (for example,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// YYYY-MM-DDTHH:MM:SSZ). The default is to start fulfilling the request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// immediately.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ValidFrom *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The end date and time of the request, in UTC format (for example,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// YYYY-MM-DDTHH:MM:SSZ). At this point, no new instance requests are placed or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// able to fulfill the request. The default end date is 7 days from the current
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// date.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ValidUntil *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Describes an EC2 Fleet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FleetEventType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FleetEventType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FleetEventTypeInstanceChange FleetEventType = "instance-change"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FleetEventTypeFleetChange    FleetEventType = "fleet-change"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FleetEventTypeServiceError   FleetEventType = "service-error"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for FleetEventType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (FleetEventType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (FleetEventType) Values() []FleetEventType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for FleetEventType. 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 FleetExcessCapacityTerminationPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FleetExcessCapacityTerminationPolicy string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FleetExcessCapacityTerminationPolicyNoTermination FleetExcessCapacityTerminationPolicy = "no-termination"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FleetExcessCapacityTerminationPolicyTermination   FleetExcessCapacityTerminationPolicy = "termination"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for FleetExcessCapacityTerminationPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (FleetExcessCapacityTerminationPolicy) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for FleetExcessCapacityTerminationPolicy. 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 FleetLaunchTemplateConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FleetLaunchTemplateConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The launch template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	LaunchTemplateSpecification *FleetLaunchTemplateSpecification
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Any parameters that you specify override the same parameters in the launch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Overrides []FleetLaunchTemplateOverrides
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Describes a launch template and overrides.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FleetLaunchTemplateConfigRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FleetLaunchTemplateConfigRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The launch template to use. You must specify either the launch template ID or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// launch template name in the request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	LaunchTemplateSpecification *FleetLaunchTemplateSpecificationRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Any parameters that you specify override the same parameters in the launch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Overrides []FleetLaunchTemplateOverridesRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Describes a launch template and overrides.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FleetLaunchTemplateOverrides

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FleetLaunchTemplateOverrides struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The Availability Zone in which to launch the instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	InstanceType InstanceType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The maximum price per unit hour that you are willing to pay for a Spot Instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MaxPrice *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The location where the instance launched, if applicable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Placement *PlacementResponse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The priority for the launch template override. If AllocationStrategy is set to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// prioritized, EC2 Fleet uses priority to determine which launch template override
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// to use first in fulfilling On-Demand capacity. The highest priority is launched
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// first. Valid values are whole numbers starting at 0. The lower the number, the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// higher the priority. If no number is set, the override has the lowest priority.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Priority float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The ID of the subnet in which to launch the instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	SubnetId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The number of units provided by the specified instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	WeightedCapacity float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Describes overrides for a launch template.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FleetLaunchTemplateOverridesRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FleetLaunchTemplateOverridesRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The Availability Zone in which to launch the instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	InstanceType InstanceType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The maximum price per unit hour that you are willing to pay for a Spot Instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MaxPrice *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The location where the instance launched, if applicable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Placement *Placement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The priority for the launch template override. If AllocationStrategy is set to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// prioritized, EC2 Fleet uses priority to determine which launch template override
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// to use first in fulfilling On-Demand capacity. The highest priority is launched
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// first. Valid values are whole numbers starting at 0. The lower the number, the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// higher the priority. If no number is set, the launch template override has the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// lowest priority.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Priority float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The IDs of the subnets in which to launch the instances. Separate multiple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// subnet IDs using commas (for example, subnet-1234abcdeexample1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// subnet-0987cdef6example2). A request of type instant can have only one subnet
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	SubnetId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The number of units provided by the specified instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	WeightedCapacity float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Describes overrides for a launch template.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FleetLaunchTemplateSpecification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FleetLaunchTemplateSpecification struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The ID of the launch template. If you specify the template ID, you can't specify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// the template name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	LaunchTemplateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The name of the launch template. If you specify the template name, you can't
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// specify the template ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	LaunchTemplateName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The launch template version number, $Latest, or $Default. You must specify a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// value, otherwise the request fails. If the value is $Latest, Amazon EC2 uses the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// latest version of the launch template. If the value is $Default, Amazon EC2 uses
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// the default version of the launch template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Version *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Describes the Amazon EC2 launch template and the launch template version that can be used by a Spot Fleet request to configure Amazon EC2 instances. For information about launch templates, see Launching an instance from a launch template (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html) in the Amazon EC2 User Guide for Linux Instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FleetLaunchTemplateSpecificationRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FleetLaunchTemplateSpecificationRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The ID of the launch template. If you specify the template ID, you can't specify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// the template name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	LaunchTemplateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The name of the launch template. If you specify the template name, you can't
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// specify the template ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	LaunchTemplateName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The launch template version number, $Latest, or $Default. You must specify a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// value, otherwise the request fails. If the value is $Latest, Amazon EC2 uses the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// latest version of the launch template. If the value is $Default, Amazon EC2 uses
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// the default version of the launch template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Version *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Describes the Amazon EC2 launch template and the launch template version that can be used by an EC2 Fleet to configure Amazon EC2 instances. For information about launch templates, see Launching an instance from a launch template (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html) in the Amazon EC2 User Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FleetOnDemandAllocationStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FleetOnDemandAllocationStrategy string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FleetOnDemandAllocationStrategyLowestPrice FleetOnDemandAllocationStrategy = "lowest-price"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FleetOnDemandAllocationStrategyPrioritized FleetOnDemandAllocationStrategy = "prioritized"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for FleetOnDemandAllocationStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (FleetOnDemandAllocationStrategy) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for FleetOnDemandAllocationStrategy. 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 FleetReplacementStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FleetReplacementStrategy string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FleetReplacementStrategyLaunch FleetReplacementStrategy = "launch"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for FleetReplacementStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (FleetReplacementStrategy) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for FleetReplacementStrategy. 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 FleetSpotCapacityRebalance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FleetSpotCapacityRebalance struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// To allow EC2 Fleet to launch a replacement Spot Instance when an instance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// rebalance notification is emitted for an existing Spot Instance in the fleet,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// specify launch. Only available for fleets of type maintain. When a replacement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// instance is launched, the instance marked for rebalance is not automatically
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// terminated. You can terminate it, or you can leave it running. You are charged
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// for both instances while they are running.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ReplacementStrategy FleetReplacementStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FleetSpotCapacityRebalanceRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FleetSpotCapacityRebalanceRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The replacement strategy to use. Only available for fleets of type maintain. To
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// allow EC2 Fleet to launch a replacement Spot Instance when an instance rebalance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// notification is emitted for an existing Spot Instance in the fleet, specify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// launch. You must specify a value, otherwise you get an error. When a replacement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// instance is launched, the instance marked for rebalance is not automatically
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// terminated. You can terminate it, or you can leave it running. You are charged
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// for all instances while they are running.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ReplacementStrategy FleetReplacementStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The Spot Instance replacement strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted. For more information, see Capacity rebalancing (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-configuration-strategies.html#ec2-fleet-capacity-rebalance) in the Amazon EC2 User Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FleetSpotMaintenanceStrategies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FleetSpotMaintenanceStrategies struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// an elevated risk of being interrupted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CapacityRebalance *FleetSpotCapacityRebalance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The strategies for managing your Spot Instances that are at an elevated risk of being interrupted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FleetSpotMaintenanceStrategiesRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FleetSpotMaintenanceStrategiesRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// an elevated risk of being interrupted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CapacityRebalance *FleetSpotCapacityRebalanceRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The strategies for managing your Spot Instances that are at an elevated risk of being interrupted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FleetStateCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FleetStateCode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FleetStateCodeSubmitted                   FleetStateCode = "submitted"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FleetStateCodeActive                      FleetStateCode = "active"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FleetStateCodeDeleted                     FleetStateCode = "deleted"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FleetStateCodeFailed                      FleetStateCode = "failed"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FleetStateCodeDeletedRunning              FleetStateCode = "deleted_running"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FleetStateCodeDeletedTerminatingInstances FleetStateCode = "deleted_terminating"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FleetStateCodeModifying                   FleetStateCode = "modifying"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for FleetStateCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (FleetStateCode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (FleetStateCode) Values() []FleetStateCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for FleetStateCode. 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 FleetType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FleetType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FleetTypeRequest  FleetType = "request"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FleetTypeMaintain FleetType = "maintain"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FleetTypeInstant  FleetType = "instant"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for FleetType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (FleetType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (FleetType) Values() []FleetType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for FleetType. 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 FlowLog

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FlowLog struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The date and time the flow log was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	CreationTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Information about the error that occurred. Rate limited indicates that
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// CloudWatch Logs throttling has been applied for one or more network interfaces,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// or that you've reached the limit on the number of log groups that you can
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// create. Access error indicates that the IAM role associated with the flow log
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// does not have sufficient permissions to publish to CloudWatch Logs. Unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// error indicates an internal error.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	DeliverLogsErrorMessage *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The ARN of the IAM role that posts logs to CloudWatch Logs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	DeliverLogsPermissionArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The status of the logs delivery (SUCCESS | FAILED).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	DeliverLogsStatus *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The flow log ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	FlowLogId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The status of the flow log (ACTIVE).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	FlowLogStatus *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Specifies the destination to which the flow log data is published. Flow log data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// can be published to an CloudWatch Logs log group or an Amazon S3 bucket. If the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// flow log publishes to CloudWatch Logs, this element indicates the Amazon
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Resource Name (ARN) of the CloudWatch Logs log group to which the data is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// published. If the flow log publishes to Amazon S3, this element indicates the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// ARN of the Amazon S3 bucket to which the data is published.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	LogDestination *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Specifies the type of destination to which the flow log data is published. Flow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// log data can be published to CloudWatch Logs or Amazon S3.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	LogDestinationType LogDestinationType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The format of the flow log record.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	LogFormat *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The name of the flow log group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	LogGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The maximum interval of time, in seconds, during which a flow of packets is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// captured and aggregated into a flow log record. When a network interface is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// attached to a Nitro-based instance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// the aggregation interval is always 60 seconds (1 minute) or less, regardless of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// the specified value. Valid Values: 60 | 600
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MaxAggregationInterval int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The ID of the resource on which the flow log was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ResourceId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The tags for the flow log.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The type of traffic captured for the flow log.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	TrafficType TrafficType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Describes a flow log.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FlowLogsResourceType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FlowLogsResourceType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FlowLogsResourceTypeVpc              FlowLogsResourceType = "VPC"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FlowLogsResourceTypeSubnet           FlowLogsResourceType = "Subnet"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FlowLogsResourceTypeNetworkInterface FlowLogsResourceType = "NetworkInterface"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for FlowLogsResourceType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (FlowLogsResourceType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for FlowLogsResourceType. 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 FpgaDeviceInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FpgaDeviceInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The count of FPGA accelerators for the instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Count *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The manufacturer of the FPGA accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Manufacturer *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Describes the memory for the FPGA accelerator for the instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	MemoryInfo *FpgaDeviceMemoryInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The name of the FPGA accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Describes the FPGA accelerator for the instance type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FpgaDeviceMemoryInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FpgaDeviceMemoryInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The size of the memory available to the FPGA accelerator, in MiB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SizeInMiB *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Describes the memory for the FPGA accelerator for the instance type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FpgaImage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FpgaImage struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The date and time the AFI was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CreateTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Indicates whether data retention support is enabled for the AFI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	DataRetentionSupport bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The description of the AFI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The global FPGA image identifier (AGFI ID).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FpgaImageGlobalId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The FPGA image identifier (AFI ID).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FpgaImageId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the AFI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The alias of the AFI owner. Possible values include self, amazon, and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// aws-marketplace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	OwnerAlias *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The AWS account ID of the AFI owner.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	OwnerId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Information about the PCI bus.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	PciId *PciId
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The product codes for the AFI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ProductCodes []ProductCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Indicates whether the AFI is public.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Public bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The version of the AWS Shell that was used to create the bitstream.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ShellVersion *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Information about the state of the AFI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	State *FpgaImageState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Any tags assigned to the AFI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The time of the most recent update to the AFI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	UpdateTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Describes an Amazon FPGA image (AFI).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FpgaImageAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FpgaImageAttribute struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The description of the AFI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ID of the AFI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FpgaImageId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The load permissions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	LoadPermissions []LoadPermission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the AFI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The product codes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ProductCodes []ProductCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Describes an Amazon FPGA image (AFI) attribute.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FpgaImageAttributeName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FpgaImageAttributeName string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FpgaImageAttributeNameDescription    FpgaImageAttributeName = "description"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FpgaImageAttributeNameName           FpgaImageAttributeName = "name"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FpgaImageAttributeNameLoadPermission FpgaImageAttributeName = "loadPermission"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FpgaImageAttributeNameProductCodes   FpgaImageAttributeName = "productCodes"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for FpgaImageAttributeName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (FpgaImageAttributeName) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for FpgaImageAttributeName. 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 FpgaImageState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FpgaImageState struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The state. The following are the possible values:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// * pending - AFI bitstream
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// generation is in progress.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// * available - The AFI is available for use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// failed - AFI bitstream generation failed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// * unavailable - The AFI is no longer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// available for use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Code FpgaImageStateCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// If the state is failed, this is the error message.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Describes the state of the bitstream generation process for an Amazon FPGA image (AFI).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FpgaImageStateCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FpgaImageStateCode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FpgaImageStateCodePending     FpgaImageStateCode = "pending"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FpgaImageStateCodeFailed      FpgaImageStateCode = "failed"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FpgaImageStateCodeAvailable   FpgaImageStateCode = "available"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FpgaImageStateCodeUnavailable FpgaImageStateCode = "unavailable"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for FpgaImageStateCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (FpgaImageStateCode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for FpgaImageStateCode. 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 FpgaInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FpgaInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Describes the FPGAs for the instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Fpgas []FpgaDeviceInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The total memory of all FPGA accelerators for the instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TotalFpgaMemoryInMiB *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Describes the FPGAs for the instance type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GatewayType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GatewayType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	GatewayTypeIpsec1 GatewayType = "ipsec.1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for GatewayType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (GatewayType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (GatewayType) Values() []GatewayType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for GatewayType. 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 GpuDeviceInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GpuDeviceInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The number of GPUs for the instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Count *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The manufacturer of the GPU accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Manufacturer *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Describes the memory available to the GPU accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	MemoryInfo *GpuDeviceMemoryInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The name of the GPU accelerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Describes the GPU accelerators for the instance type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GpuDeviceMemoryInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GpuDeviceMemoryInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The size of the memory available to the GPU accelerator, in MiB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	SizeInMiB *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Describes the memory available to the GPU accelerator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GpuInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GpuInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Describes the GPU accelerators for the instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Gpus []GpuDeviceInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The total size of the memory for the GPU accelerators for the instance type, in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// MiB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TotalGpuMemoryInMiB *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Describes the GPU accelerators for the instance type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GroupIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GroupIdentifier struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The ID of the security group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	GroupId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The name of the security group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	GroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Describes a security group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HibernationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HibernationOptions struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// If this parameter is set to true, your instance is enabled for hibernation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// otherwise, it is not enabled for hibernation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Configured bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Indicates whether your instance is configured for hibernation. This parameter is valid only if the instance meets the hibernation prerequisites (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html#hibernating-prerequisites). For more information, see Hibernate your instance (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html) in the Amazon EC2 User Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HibernationOptionsRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HibernationOptionsRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// If you set this parameter to true, your instance is enabled for hibernation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Default: false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Configured bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Indicates whether your instance is configured for hibernation. This parameter is valid only if the instance meets the hibernation prerequisites (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html#hibernating-prerequisites). For more information, see Hibernate your instance (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html) in the Amazon EC2 User Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HistoryRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HistoryRecord struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Information about the event.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EventInformation *EventInformation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The event type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// * error - An error with the Spot Fleet request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// fleetRequestChange - A change in the status or configuration of the Spot Fleet
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// * instanceChange - An instance was launched or terminated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Information - An informational event.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EventType EventType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The date and time of the event, in UTC format (for example,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// YYYY-MM-DDTHH:MM:SSZ).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Timestamp *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Describes an event in the history of the Spot Fleet request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HistoryRecordEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HistoryRecordEntry struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Information about the event.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	EventInformation *EventInformation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The event type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	EventType FleetEventType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The date and time of the event, in UTC format (for example,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// YYYY-MM-DDTHH:MM:SSZ).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Timestamp *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Describes an event in the history of an EC2 Fleet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Host struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The time that the Dedicated Host was allocated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AllocationTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Indicates whether the Dedicated Host supports multiple instance types of the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// same instance family. If the value is on, the Dedicated Host supports multiple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// instance types in the instance family. If the value is off, the Dedicated Host
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// supports a single instance type only.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AllowsMultipleInstanceTypes AllowsMultipleInstanceTypes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Whether auto-placement is on or off.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AutoPlacement AutoPlacement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The Availability Zone of the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the Availability Zone in which the Dedicated Host is allocated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AvailabilityZoneId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Information about the instances running on the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AvailableCapacity *AvailableCapacity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// the request. For more information, see Ensuring Idempotency
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ClientToken *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HostId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The hardware specifications of the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HostProperties *HostProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Indicates whether host recovery is enabled or disabled for the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HostRecovery HostRecovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The reservation ID of the Dedicated Host. This returns a null response if the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Dedicated Host doesn't have an associated reservation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HostReservationId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The IDs and instance type that are currently running on the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Instances []HostInstance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Indicates whether the Dedicated Host is in a host resource group. If
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// memberOfServiceLinkedResourceGroup is true, the host is in a host resource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// group; otherwise, it is not.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	MemberOfServiceLinkedResourceGroup bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the AWS account that owns the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	OwnerId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The time that the Dedicated Host was released.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ReleaseTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The Dedicated Host's state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	State AllocationState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Any tags assigned to the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Describes the properties of the Dedicated Host.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HostInstance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HostInstance struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The ID of instance that is running on the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	InstanceId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The instance type (for example, m3.medium) of the running instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	InstanceType *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The ID of the AWS account that owns the instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	OwnerId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Describes an instance running on a Dedicated Host.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HostOffering

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HostOffering struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The currency of the offering.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CurrencyCode CurrencyCodeValues
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The duration of the offering (in seconds).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Duration int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The hourly price of the offering.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	HourlyPrice *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The instance family of the offering.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	InstanceFamily *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The ID of the offering.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	OfferingId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The available payment option.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	PaymentOption PaymentOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The upfront price of the offering. Does not apply to No Upfront offerings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	UpfrontPrice *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Details about the Dedicated Host Reservation offering.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HostProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HostProperties struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The number of cores on the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Cores int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The instance family supported by the Dedicated Host. For example, m5.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InstanceFamily *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The instance type supported by the Dedicated Host. For example, m5.large. If the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// host supports multiple instance types, no instanceType is returned.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InstanceType *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The number of sockets on the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Sockets int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The total number of vCPUs on the Dedicated Host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TotalVCpus int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Describes the properties of a Dedicated Host.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HostRecovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HostRecovery string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HostRecoveryOn  HostRecovery = "on"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HostRecoveryOff HostRecovery = "off"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for HostRecovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (HostRecovery) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (HostRecovery) Values() []HostRecovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for HostRecovery. 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 HostReservation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HostReservation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The number of Dedicated Hosts the reservation is associated with.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Count int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The currency in which the upfrontPrice and hourlyPrice amounts are specified. At
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// this time, the only supported currency is USD.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CurrencyCode CurrencyCodeValues
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The length of the reservation's term, specified in seconds. Can be 31536000 (1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// year) | 94608000 (3 years).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Duration int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The date and time that the reservation ends.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	End *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The IDs of the Dedicated Hosts associated with the reservation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	HostIdSet []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The ID of the reservation that specifies the associated Dedicated Hosts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	HostReservationId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The hourly price of the reservation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	HourlyPrice *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The instance family of the Dedicated Host Reservation. The instance family on
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// the Dedicated Host must be the same in order for it to benefit from the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// reservation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	InstanceFamily *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The ID of the reservation. This remains the same regardless of which Dedicated
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Hosts are associated with it.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	OfferingId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The payment option selected for this reservation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	PaymentOption PaymentOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The date and time that the reservation started.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Start *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The state of the reservation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	State ReservationState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Any tags assigned to the Dedicated Host Reservation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The upfront price of the reservation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	UpfrontPrice *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Details about the Dedicated Host Reservation and associated Dedicated Hosts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HostTenancy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HostTenancy string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	HostTenancyDedicated HostTenancy = "dedicated"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	HostTenancyHost      HostTenancy = "host"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for HostTenancy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (HostTenancy) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (HostTenancy) Values() []HostTenancy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for HostTenancy. 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 HttpTokensState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HttpTokensState string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HttpTokensStateOptional HttpTokensState = "optional"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HttpTokensStateRequired HttpTokensState = "required"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for HttpTokensState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (HttpTokensState) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (HttpTokensState) Values() []HttpTokensState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for HttpTokensState. 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 HypervisorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HypervisorType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	HypervisorTypeOvm HypervisorType = "ovm"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	HypervisorTypeXen HypervisorType = "xen"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for HypervisorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (HypervisorType) Values