types

package
v0.26.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 30, 2020 License: Apache-2.0 Imports: 1 Imported by: 0

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

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 ID of the Spot Instance request.
	SpotInstanceRequestId *string
	// The ID of the instance.
	InstanceId *string
	// 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 instance type.
	InstanceType *string
}

Describes a running instance in a Spot Fleet.

type ActivityStatus 

type ActivityStatus string
const (
	ActivityStatusError               ActivityStatus = "error"
	ActivityStatusPending_fulfillment ActivityStatus = "pending_fulfillment"
	ActivityStatusPending_termination ActivityStatus = "pending_termination"
	ActivityStatusFulfilled           ActivityStatus = "fulfilled"
)

Enum values for ActivityStatus

type AddPrefixListEntry 

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

An entry for a prefix list.

type Address 

type Address struct {
	// Indicates whether this Elastic IP address is for use with instances in
	// EC2-Classic (standard) or instances in a VPC (vpc).
	Domain DomainType
	// The customer-owned IP address.
	CustomerOwnedIp *string
	// The private IP address associated with the Elastic IP address.
	PrivateIpAddress *string
	// Any tags assigned to the Elastic IP address.
	Tags []*Tag
	// The ID representing the allocation of the address for use with EC2-VPC.
	AllocationId *string
	// The ID of the customer-owned address pool.
	CustomerOwnedIpv4Pool *string
	// The ID of an address pool.
	PublicIpv4Pool *string
	// The name of the location from which the IP address is advertised.
	NetworkBorderGroup *string
	// The ID of the network interface.
	NetworkInterfaceId *string
	// The ID of the instance that the address is associated with (if any).
	InstanceId *string
	// The Elastic IP address.
	PublicIp *string
	// The ID of the AWS account that owns the network interface.
	NetworkInterfaceOwnerId *string
	// The ID representing the association of the address with an instance in a VPC.
	AssociationId *string
}

Describes an Elastic IP address.

type Affinity 

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

Enum values for Affinity

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

type AllocationStrategy 

type AllocationStrategy string
const (
	AllocationStrategyLowest_price       AllocationStrategy = "lowestPrice"
	AllocationStrategyDiversified        AllocationStrategy = "diversified"
	AllocationStrategyCapacity_optimized AllocationStrategy = "capacityOptimized"
)

Enum values for AllocationStrategy

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

type ArchitectureType 

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

Enum values for ArchitectureType

type ArchitectureValues 

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

Enum values for ArchitectureValues

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

type AssociatedTargetNetwork 

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

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

type AttachmentStatus 

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

Enum values for AttachmentStatus

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 {
	// The ID of the Active Directory group to which the authorization rule grants
	// access.
	GroupId *string
	// 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 current state of the authorization rule.
	Status *ClientVpnAuthorizationRuleStatus
	// The IPv4 address range, in CIDR notation, of the network to which the
	// authorization rule applies.
	DestinationCidr *string
	// Indicates whether the authorization rule grants access to all clients.
	AccessAll *bool
}

Information about an authorization rule.

type AutoAcceptSharedAttachmentsValue 

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

Enum values for AutoAcceptSharedAttachmentsValue

type AutoPlacement 

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

Enum values for AutoPlacement

type AvailabilityZone 

type AvailabilityZone struct {
	// The ID of the zone that handles some of the Local Zone control plane operations,
	// such as API calls.
	ParentZoneId *string
	// 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.
	GroupName *string
	// The name of the zone that handles some of the Local Zone control plane
	// operations, such as API calls.
	ParentZoneName *string
	// The type of zone. The valid values are availability-zone and local-zone.
	ZoneType *string
	// The ID of the Zone.
	ZoneId *string
	// The state of the Zone.
	State AvailabilityZoneState
	// The name of the Region.
	RegionName *string
	// The name of the location from which the address is advertised.
	NetworkBorderGroup *string
	// The name of the Zone.
	ZoneName *string
	// Any messages about the Zone.
	Messages []*AvailabilityZoneMessage
	// For Availability Zones, this parameter always has the value of
	// opt-in-not-required. For Local Zones, this parameter is the opt in status. The
	// possible values are opted-in, and not-opted-in.
	OptInStatus AvailabilityZoneOptInStatus
}

Describes a Zone.

type AvailabilityZoneMessage 

type AvailabilityZoneMessage struct {
	// The message about the Zone.
	Message *string
}

Describes a message about a 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

type AvailabilityZoneState 

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

Enum values for AvailabilityZoneState

type AvailableCapacity 

type AvailableCapacity struct {
	// The number of vCPUs available for launching instances onto the Dedicated Host.
	AvailableVCpus *int32
	// 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 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"
	BatchStateCancelled_running               BatchState = "cancelled_running"
	BatchStateCancelled_terminating_instances BatchState = "cancelled_terminating"
	BatchStateModifying                       BatchState = "modifying"
)

Enum values for BatchState

type BlobAttributeValue 

type BlobAttributeValue struct {
	Value []byte
}

type BlockDeviceMapping 

type BlockDeviceMapping struct {
	// The device name (for example, /dev/sdh or xvdh).
	DeviceName *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
	// Parameters used to automatically set up EBS volumes when the instance is
	// launched.
	Ebs *EbsBlockDevice
	// Suppresses the specified device included in the block device mapping of the AMI.
	NoDevice *string
}

Describes a block device mapping.

type BundleTask 

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

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

type ByoipCidr 

type ByoipCidr struct {
	// The state of the address pool.
	State ByoipCidrState
	// The description of the address range.
	Description *string
	// The address range, in CIDR notation.
	Cidr *string
	// 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

type CancelBatchErrorCode 

type CancelBatchErrorCode string
const (
	CancelBatchErrorCodeFleet_request_id_does_not_exist        CancelBatchErrorCode = "fleetRequestIdDoesNotExist"
	CancelBatchErrorCodeFleet_request_id_malformed             CancelBatchErrorCode = "fleetRequestIdMalformed"
	CancelBatchErrorCodeFleet_request_not_in_cancellable_state CancelBatchErrorCode = "fleetRequestNotInCancellableState"
	CancelBatchErrorCodeUnexpected_error                       CancelBatchErrorCode = "unexpectedError"
)

Enum values for CancelBatchErrorCode

type CancelSpotFleetRequestsError 

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

Describes a Spot Fleet error.

type CancelSpotFleetRequestsErrorItem 

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

Describes a Spot Fleet request that was not successfully canceled.

type CancelSpotFleetRequestsSuccessItem 

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

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

type CancelledSpotInstanceRequest 

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

Describes a request to cancel a Spot Instance.

type CapacityReservation 

type CapacityReservation struct {
	// The type of instance for which the Capacity Reservation reserves capacity.
	InstanceType *string
	// The remaining capacity. Indicates the number of instances that can be launched
	// in the Capacity Reservation.
	AvailableInstanceCount *int32
	// Any tags assigned to the Capacity Reservation.
	Tags []*Tag
	// The ID of the Capacity Reservation.
	CapacityReservationId *string
	// The total number of instances for which the Capacity Reservation reserves
	// capacity.
	TotalInstanceCount *int32
	// The ID of the AWS account that owns the Capacity Reservation.
	OwnerId *string
	// The Availability Zone in which the capacity is reserved.
	AvailabilityZone *string
	// 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
	// The Amazon Resource Name (ARN) of the Capacity Reservation.
	CapacityReservationArn *string
	// 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
	// Indicates whether the Capacity Reservation supports instances with temporary,
	// block-level storage.
	EphemeralStorage *bool
	// The type of operating system for which the Capacity Reservation reserves
	// capacity.
	InstancePlatform CapacityReservationInstancePlatform
	// The Availability Zone ID of the Capacity Reservation.
	AvailabilityZoneId *string
	// 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 date and time at which the Capacity Reservation was created.
	CreateDate *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 manually 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
	// 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 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
}

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 (
	CapacityReservationInstancePlatformLinux_unix                         CapacityReservationInstancePlatform = "Linux/UNIX"
	CapacityReservationInstancePlatformRed_hat_enterprise_linux           CapacityReservationInstancePlatform = "Red Hat Enterprise Linux"
	CapacityReservationInstancePlatformSuse_linux                         CapacityReservationInstancePlatform = "SUSE Linux"
	CapacityReservationInstancePlatformWindows                            CapacityReservationInstancePlatform = "Windows"
	CapacityReservationInstancePlatformWindows_with_sql_server            CapacityReservationInstancePlatform = "Windows with SQL Server"
	CapacityReservationInstancePlatformWindows_with_sql_server_enterprise CapacityReservationInstancePlatform = "Windows with SQL Server Enterprise"
	CapacityReservationInstancePlatformWindows_with_sql_server_standard   CapacityReservationInstancePlatform = "Windows with SQL Server Standard"
	CapacityReservationInstancePlatformWindows_with_sql_server_web        CapacityReservationInstancePlatform = "Windows with SQL Server Web"
	CapacityReservationInstancePlatformLinux_with_sql_server_standard     CapacityReservationInstancePlatform = "Linux with SQL Server Standard"
	CapacityReservationInstancePlatformLinux_with_sql_server_web          CapacityReservationInstancePlatform = "Linux with SQL Server Web"
	CapacityReservationInstancePlatformLinux_with_sql_server_enterprise   CapacityReservationInstancePlatform = "Linux with SQL Server Enterprise"
	CapacityReservationInstancePlatformByol_windows                       CapacityReservationInstancePlatform = "Windows BYOL"
)

Enum values for CapacityReservationInstancePlatform

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 Elastic Compute Cloud 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 Elastic Compute Cloud 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 Elastic Compute Cloud 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 Elastic Compute Cloud User Guide.

type CapacityReservationPreference 

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

Enum values for CapacityReservationPreference

type CapacityReservationSpecification 

type CapacityReservationSpecification struct {
	// Information about the target Capacity Reservation or Capacity Reservation group.
	CapacityReservationTarget *CapacityReservationTarget
	// 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
}

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 {
	// Information about the targeted Capacity Reservation or Capacity Reservation
	// group.
	CapacityReservationTarget *CapacityReservationTargetResponse
	// 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
}

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

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

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 signed authorization message for the prefix and account.
	Signature *string
	// The plain-text authorization message for the prefix and account.
	Message *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 {
	// The ID of the instance.
	InstanceId *string
	// The ID of the VPC.
	VpcId *string
	// A list of security groups.
	Groups []*GroupIdentifier
	// Any tags assigned to the instance.
	Tags []*Tag
}

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

type ClientData 

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

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
	// The authentication type used.
	Type ClientVpnAuthenticationType
	// Information about the authentication certificates, if applicable.
	MutualAuthentication *CertificateAuthentication
}

Describes the authentication methods 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 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

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

type ClientVpnConnection 

type ClientVpnConnection struct {
	// The number of packets received by the client.
	EgressPackets *string
	// The ID of the client connection.
	ConnectionId *string
	// The number of bytes received by the client.
	EgressBytes *string
	// The date and time the client connection was established.
	ConnectionEstablishedTime *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
	// The current date and time.
	Timestamp *string
	// The IP address of the client.
	ClientIp *string
	// The number of bytes sent by the client.
	IngressBytes *string
	// The current state of the client connection.
	Status *ClientVpnConnectionStatus
	// The number of packets sent by the client.
	IngressPackets *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 ID of the Client VPN endpoint to which the client is connected.
	ClientVpnEndpointId *string
	// The date and time the client connection was terminated.
	ConnectionEndTime *string
}

Describes a client connection.

type ClientVpnConnectionStatus 

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

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

type ClientVpnEndpoint 

type ClientVpnEndpoint struct {
	// The ARN of the server certificate.
	ServerCertificateArn *string
	// The ID of the Client VPN endpoint.
	ClientVpnEndpointId *string
	// The current state of the Client VPN endpoint.
	Status *ClientVpnEndpointStatus
	// Any tags assigned to the Client VPN endpoint.
	Tags []*Tag
	// The IPv4 address range, in CIDR notation, from which client IP addresses are
	// assigned.
	ClientCidrBlock *string
	// The IDs of the security groups for the target network.
	SecurityGroupIds []*string
	// The protocol used by the VPN session.
	VpnProtocol VpnProtocol
	// Information about the associated target networks. A target network is a subnet
	// in a VPC.
	AssociatedTargetNetworks []*AssociatedTargetNetwork
	// Information about the authentication method used by the Client VPN endpoint.
	AuthenticationOptions []*ClientVpnAuthentication
	// 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 port number for the Client VPN endpoint.
	VpnPort *int32
	// Information about the DNS servers to be used for DNS resolution.
	DnsServers []*string
	// The date and time the Client VPN endpoint was deleted, if applicable.
	DeletionTime *string
	// The DNS name to be used by clients when connecting to the Client VPN endpoint.
	DnsName *string
	// A brief description of the endpoint.
	Description *string
	// Information about the client connection logging options for the Client VPN
	// endpoint.
	ConnectionLogOptions *ConnectionLogResponseOptions
	// The transport protocol used by the Client VPN endpoint.
	TransportProtocol TransportProtocol
	// The date and time the Client VPN endpoint was created.
	CreationTime *string
	// The ID of the VPC.
	VpcId *string
}

Describes a Client VPN endpoint.

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

type ClientVpnRoute 

type ClientVpnRoute struct {
	// The ID of the subnet through which traffic is routed.
	TargetSubnet *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 IPv4 address range, in CIDR notation, of the route destination.
	DestinationCidr *string
	// The route type.
	Type *string
	// The current state of the route.
	Status *ClientVpnRouteStatus
	// The ID of the Client VPN endpoint with which the route is associated.
	ClientVpnEndpointId *string
	// A brief description of the route.
	Description *string
}

Information about a Client VPN endpoint route.

type ClientVpnRouteStatus 

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

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

type CoipAddressUsage 

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

Describes address usage for a customer-owned address pool.

type CoipPool 

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

Describes a customer-owned address pool.

type ConnectionLogOptions 

type ConnectionLogOptions struct {
	// The name of the CloudWatch Logs log stream to which the connection data is
	// published.
	CloudwatchLogStream *string
	// The name of the CloudWatch Logs log group. Required if connection logging is
	// enabled.
	CloudwatchLogGroup *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
	// Indicates whether client connection logging is enabled for the Client VPN
	// endpoint.
	Enabled *bool
	// The name of the Amazon CloudWatch Logs log stream to which connection logging
	// data is published.
	CloudwatchLogStream *string
}

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

type ConnectionNotification 

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

type ConnectionNotificationType 

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

Enum values for ConnectionNotificationType

type ContainerFormat 

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

Enum values for ContainerFormat

type ConversionTask 

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

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

type CopyTagsFromSource 

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

Enum values for CopyTagsFromSource

type CpuOptions 

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

The CPU options for the instance.

type CpuOptionsRequest 

type CpuOptionsRequest struct {
	// 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 number of CPU cores for the instance.
	CoreCount *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 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
	// Indicates if the instance that could not be launched was a Spot Instance or
	// On-Demand Instance.
	Lifecycle InstanceLifecycle
	// 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 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
}

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

type CreateFleetInstance 

type CreateFleetInstance struct {
	// Indicates if the instance that was launched is a Spot Instance or On-Demand
	// Instance.
	Lifecycle InstanceLifecycle
	// The instance type.
	InstanceType InstanceType
	// The IDs of the instances.
	InstanceIds []*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
	// The value is Windows for Windows instances. Otherwise, the value is blank.
	Platform PlatformValues
}

Describes the instances that were launched by the fleet.

type CreateTransitGatewayVpcAttachmentRequestOptions 

type CreateTransitGatewayVpcAttachmentRequestOptions struct {
	// Enable or disable IPv6 support. The default is enable.
	Ipv6Support Ipv6SupportValue
	// Enable or disable DNS support. The default is enable.
	DnsSupport DnsSupportValue
}

Describes the options for a VPC attachment.

type CreateVolumePermission 

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

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 {
	// Removes the specified AWS account ID or group from the list.
	Remove []*CreateVolumePermission
	// Adds the specified AWS account ID or group to the list.
	Add []*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.
	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

type CustomerGateway 

type CustomerGateway struct {
	// 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
	// The ID of the customer gateway.
	CustomerGatewayId *string
	// The Amazon Resource Name (ARN) for the customer gateway certificate.
	CertificateArn *string
	// The type of VPN connection the customer gateway supports (ipsec.1).
	Type *string
	// Any tags assigned to the customer gateway.
	Tags []*Tag
	// The customer gateway's Border Gateway Protocol (BGP) Autonomous System Number
	// (ASN).
	BgpAsn *string
	// The name of customer gateway device.
	DeviceName *string
}

Describes a customer gateway.

type DatafeedSubscriptionState 

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

Enum values for DatafeedSubscriptionState

type DefaultRouteTableAssociationValue 

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

Enum values for DefaultRouteTableAssociationValue

type DefaultRouteTablePropagationValue 

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

Enum values for DefaultRouteTablePropagationValue

type DefaultTargetCapacityType 

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

Enum values for DefaultTargetCapacityType

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 (
	DeleteFleetErrorCodeFleet_id_does_not_exist      DeleteFleetErrorCode = "fleetIdDoesNotExist"
	DeleteFleetErrorCodeFleet_id_malformed           DeleteFleetErrorCode = "fleetIdMalformed"
	DeleteFleetErrorCodeFleet_not_in_deletable_state DeleteFleetErrorCode = "fleetNotInDeletableState"
	DeleteFleetErrorCodeUnexpected_error             DeleteFleetErrorCode = "unexpectedError"
)

Enum values for DeleteFleetErrorCode

type DeleteFleetErrorItem 

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

Describes an EC2 Fleet that was not successfully deleted.

type DeleteFleetSuccessItem 

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

Describes an EC2 Fleet that was successfully deleted.

type DeleteLaunchTemplateVersionsResponseErrorItem 

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

Describes a launch template version that could not be deleted.

type DeleteLaunchTemplateVersionsResponseSuccessItem 

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

Describes a launch template version that was successfully deleted.

type DeleteQueuedReservedInstancesError 

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

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

type DeleteQueuedReservedInstancesErrorCode 

type DeleteQueuedReservedInstancesErrorCode string
const (
	DeleteQueuedReservedInstancesErrorCodeReserved_instances_id_invalid          DeleteQueuedReservedInstancesErrorCode = "reserved-instances-id-invalid"
	DeleteQueuedReservedInstancesErrorCodeReserved_instances_not_in_queued_state DeleteQueuedReservedInstancesErrorCode = "reserved-instances-not-in-queued-state"
	DeleteQueuedReservedInstancesErrorCodeUnexpected_error                       DeleteQueuedReservedInstancesErrorCode = "unexpected-error"
)

Enum values for DeleteQueuedReservedInstancesErrorCode

type DeregisterInstanceTagAttributeRequest 

type DeregisterInstanceTagAttributeRequest struct {
	// Information about the tag keys to deregister.
	InstanceTagKeys []*string
	// 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 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 ID of the snapshot.
	SnapshotId *string
	// The time at which fast snapshot restores entered the enabled state.
	EnabledTime *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 optimizing state.
	OptimizingTime *time.Time
	// The time at which fast snapshot restores entered the disabled state.
	DisabledTime *time.Time
	// The ID of the AWS account that enabled fast snapshot restores on the snapshot.
	OwnerId *string
	// The time at which fast snapshot restores entered the enabling state.
	EnablingTime *time.Time
	// The Availability Zone.
	AvailabilityZone *string
	// The state of fast snapshot restores.
	State FastSnapshotRestoreStateCode
	// The AWS owner alias that enabled fast snapshot restores on the snapshot. This is
	// intended for future use.
	OwnerAlias *string
	// 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
	// Indicates if the instance that could not be launched was a Spot Instance or
	// On-Demand Instance.
	Lifecycle InstanceLifecycle
	// 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
}

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

type DescribeFleetsInstances 

type DescribeFleetsInstances struct {
	// The IDs of the instances.
	InstanceIds []*string
	// 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
	// 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
}

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

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
	// Any tags assigned to the DHCP options set.
	Tags []*Tag
	// The ID of the set of DHCP options.
	DhcpOptionsId *string
	// The ID of the AWS account that owns the DHCP options set.
	OwnerId *string
}

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 ID of the snapshot.
	SnapshotId *string
	// The errors.
	FastSnapshotRestoreStateErrors []*DisableFastSnapshotRestoreStateErrorItem
}

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 state of fast snapshot restores for the snapshot.
	State FastSnapshotRestoreStateCode
	// The time at which fast snapshot restores entered the enabling state.
	EnablingTime *time.Time
	// The time at which fast snapshot restores entered the disabled state.
	DisabledTime *time.Time
	// The Availability Zone.
	AvailabilityZone *string
	// The ID of the AWS account that enabled fast snapshot restores on the snapshot.
	OwnerId *string
	// The time at which fast snapshot restores entered the optimizing state.
	OptimizingTime *time.Time
	// The time at which fast snapshot restores entered the enabled state.
	EnabledTime *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 snapshot.
	SnapshotId *string
	// The time at which fast snapshot restores entered the disabling state.
	DisablingTime *time.Time
	// 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 volume.
	Volume *VolumeDetail
	// Information about the disk image.
	Image *DiskImageDetail
}

Describes a disk image.

type DiskImageDescription 

type DiskImageDescription struct {
	// The checksum computed for the disk image.
	Checksum *string
	// The disk image format.
	Format DiskImageFormat
	// The size of the disk image, in GiB.
	Size *int64
	// 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
}

Describes a disk image.

type DiskImageDetail 

type DiskImageDetail struct {
	// The size of the disk image, in GiB.
	Bytes *int64
	// 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).
	ImportManifestUrl *string
	// The disk image format.
	Format DiskImageFormat
}

Describes a disk image.

type DiskImageFormat 

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

Enum values for DiskImageFormat

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 size of the disk in GB.
	SizeInGB *int64
	// The number of disks with this configuration.
	Count *int32
	// 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

type DnsEntry 

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

Describes a DNS entry.

type DnsNameState 

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

Enum values for DnsNameState

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

type DomainType 

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

Enum values for DomainType

type EbsBlockDevice 

type EbsBlockDevice struct {
	// The volume type. If you set the type to io1, you must also specify the Iops
	// parameter. If you set the type to gp2, st1, sc1, or standard, you must omit the
	// Iops parameter. Default: gp2
	VolumeType VolumeType
	// The ID of the snapshot.
	SnapshotId *string
	// The size of the volume, in GiB. Default: If you're creating the volume from a
	// snapshot and don't specify a volume size, the default is the snapshot size.
	// Constraints: 1-16384 for General Purpose SSD (gp2), 4-16384 for Provisioned IOPS
	// SSD (io1), 500-16384 for Throughput Optimized HDD (st1), 500-16384 for Cold HDD
	// (sc1), and 1-1024 for Magnetic (standard) volumes. If you specify a snapshot,
	// the volume size must be equal to or larger than the snapshot size.
	VolumeSize *int32
	// The number of I/O operations per second (IOPS) that the volume supports. For io1
	// 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. For more
	// information, see Amazon EBS volume types
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html) in the
	// Amazon Elastic Compute Cloud User Guide. Constraints: Range is 100-16,000 IOPS
	// for gp2 volumes and 100 to 64,000IOPS for io1 volumes in most Regions. Maximum
	// io1 IOPS of 64,000 is guaranteed only on Nitro-based instances
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances).
	// Other instance families guarantee performance up to 32,000 IOPS. For more
	// information, see Amazon EBS Volume Types
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html) in the
	// Amazon Elastic Compute Cloud User Guide. Condition: This parameter is required
	// for requests to create io1 volumes; it is not used in requests to create gp2,
	// st1, sc1, or standard volumes.
	Iops *int32
	// 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 Elastic Compute Cloud User Guide.
	DeleteOnTermination *bool
	// 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
	// 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 Elastic Compute Cloud 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
}

Describes a block device for an EBS volume.

type EbsEncryptionSupport 

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

Enum values for EbsEncryptionSupport

type EbsInfo 

type EbsInfo struct {
	// Indicates that 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 for Linux Instances.
	EbsOptimizedSupport EbsOptimizedSupport
	// Indicates whether non-volatile memory express (NVMe) is supported.
	NvmeSupport EbsNvmeSupport
	// Indicates whether Amazon EBS encryption is supported.
	EncryptionSupport EbsEncryptionSupport
	// Describes the optimized EBS performance for the instance type.
	EbsOptimizedInfo *EbsOptimizedInfo
}

Describes the Amazon EBS features supported by the instance type.

type EbsInstanceBlockDevice 

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

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

type EbsInstanceBlockDeviceSpecification 

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

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

type EbsOptimizedInfo 

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

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

type EgressOnlyInternetGateway 

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

Describes an egress-only internet gateway.

type ElasticGpuAssociation 

type ElasticGpuAssociation struct {
	// The ID of the Elastic Graphics accelerator.
	ElasticGpuId *string
	// The time the Elastic Graphics accelerator was associated with the instance.
	ElasticGpuAssociationTime *string
	// The ID of the association.
	ElasticGpuAssociationId *string
	// The state of the association between the instance and the Elastic Graphics
	// accelerator.
	ElasticGpuAssociationState *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.
	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

type ElasticGpuStatus 

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

Enum values for ElasticGpuStatus

type ElasticGpus 

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

Describes an Elastic Graphics accelerator.

type ElasticInferenceAccelerator 

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

Describes an elastic inference accelerator.

type ElasticInferenceAcceleratorAssociation 

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

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

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 message.
	Message *string
	// The error code.
	Code *string
}

Describes an error that occurred when enabling fast snapshot restores.

type EnableFastSnapshotRestoreStateErrorItem 

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

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

type EnableFastSnapshotRestoreSuccessItem 

type EnableFastSnapshotRestoreSuccessItem struct {
	// The ID of the AWS account that enabled fast snapshot restores on the snapshot.
	OwnerId *string
	// The Availability Zone.
	AvailabilityZone *string
	// 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
	// The AWS owner alias that enabled fast snapshot restores on the snapshot. This is
	// intended for future use.
	OwnerAlias *string
	// The time at which fast snapshot restores entered the disabling state.
	DisablingTime *time.Time
	// The time at which fast snapshot restores entered the disabled state.
	DisabledTime *time.Time
	// The ID of the snapshot.
	SnapshotId *string
	// The state of fast snapshot restores.
	State FastSnapshotRestoreStateCode
	// The time at which fast snapshot restores entered the enabling state.
	EnablingTime *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 optimizing state.
	OptimizingTime *time.Time
}

Describes fast snapshot restores that were successfully enabled.

type EndDateType 

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

Enum values for EndDateType

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

type EventInformation 

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

Describes an EC2 Fleet or Spot Fleet event.

type EventType 

type EventType string
const (
	EventTypeInstance_change EventType = "instanceChange"
	EventTypeBatch_change    EventType = "fleetRequestChange"
	EventTypeError           EventType = "error"
	EventTypeInformation     EventType = "information"
)

Enum values for EventType

type ExcessCapacityTerminationPolicy 

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

Enum values for ExcessCapacityTerminationPolicy

type ExportEnvironment 

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

Enum values for ExportEnvironment

type ExportImageTask 

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

Describes an export image task.

type ExportTask 

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

Describes an instance export task.

type ExportTaskS3Location 

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

Describes the destination for an export image task.

type ExportTaskS3LocationRequest 

type ExportTaskS3LocationRequest struct {
	// The prefix (logical hierarchy) in the bucket.
	S3Prefix *string
	// The destination Amazon S3 bucket.
	S3Bucket *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

type ExportToS3Task 

type ExportToS3Task struct {
	// The encryption key for your S3 bucket.
	S3Key *string
	// 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 container format used to combine disk images with metadata (such as OVF). If
	// absent, only the disk image is exported.
	ContainerFormat ContainerFormat
}

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 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
	// The format for the exported image.
	DiskImageFormat DiskImageFormat
}

Describes an instance export task.

type FailedQueuedPurchaseDeletion 

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

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

type FederatedAuthentication 

type FederatedAuthentication struct {
	// The Amazon Resource Name (ARN) of the IAM SAML identity provider.
	SamlProviderArn *string
}

Describes the IAM SAML identity provider used for federated authentication.

type FederatedAuthenticationRequest 

type FederatedAuthenticationRequest struct {
	// The Amazon Resource Name (ARN) of the IAM SAML identity provider.
	SAMLProviderArn *string
}

The IAM SAML identity provider used for federated authentication.

type Filter 

type Filter struct {
	// The filter values. Filter values are case-sensitive.
	Values []*string
	// The name of the filter. Filter names are case-sensitive.
	Name *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"
	FleetActivityStatusPending_fulfillment FleetActivityStatus = "pending_fulfillment"
	FleetActivityStatusPending_termination FleetActivityStatus = "pending_termination"
	FleetActivityStatusFulfilled           FleetActivityStatus = "fulfilled"
)

Enum values for FleetActivityStatus

type FleetCapacityReservationUsageStrategy 

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

Enum values for FleetCapacityReservationUsageStrategy

type FleetData 

type FleetData struct {
	// Indicates whether EC2 Fleet should replace unhealthy instances.
	ReplaceUnhealthyInstances *bool
	// The creation date and time of the EC2 Fleet.
	CreateTime *time.Time
	// Indicates whether running instances should be terminated when the EC2 Fleet
	// expires.
	TerminateInstancesWithExpiration *bool
	// The allocation strategy of On-Demand Instances in an EC2 Fleet.
	OnDemandOptions *OnDemandOptions
	// 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
	// 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
	// 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
	// Information about the instances that could not be launched by the fleet. Valid
	// only when Type is set to instant.
	Errors []*DescribeFleetError
	// 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
	// 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 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 configuration of Spot Instances in an EC2 Fleet.
	SpotOptions *SpotOptions
	// The state of the EC2 Fleet.
	FleetState FleetStateCode
	// 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
	// The launch template and overrides.
	LaunchTemplateConfigs []*FleetLaunchTemplateConfig
	// The tags for an EC2 Fleet resource.
	Tags []*Tag
	// The ID of the EC2 Fleet.
	FleetId *string
	// The number of units fulfilled by this request compared to the set target
	// capacity.
	FulfilledCapacity *float64
	// 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
}

Describes an EC2 Fleet.

type FleetEventType 

type FleetEventType string
const (
	FleetEventTypeInstance_change FleetEventType = "instance-change"
	FleetEventTypeFleet_change    FleetEventType = "fleet-change"
	FleetEventTypeService_error   FleetEventType = "service-error"
)

Enum values for FleetEventType

type FleetExcessCapacityTerminationPolicy 

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

Enum values for FleetExcessCapacityTerminationPolicy

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 number of units provided by the specified instance type.
	WeightedCapacity *float64
	// 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 Availability Zone in which to launch the instances.
	AvailabilityZone *string
	// The ID of the subnet in which to launch the instances.
	SubnetId *string
	// The location where the instance launched, if applicable.
	Placement *PlacementResponse
	// The instance type.
	InstanceType InstanceType
	// The maximum price per unit hour that you are willing to pay for a Spot Instance.
	MaxPrice *string
}

Describes overrides for a launch template.

type FleetLaunchTemplateOverridesRequest 

type FleetLaunchTemplateOverridesRequest struct {
	// The instance type.
	InstanceType InstanceType
	// 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 maximum price per unit hour that you are willing to pay for a Spot Instance.
	MaxPrice *string
	// The number of units provided by the specified instance type.
	WeightedCapacity *float64
	// The Availability Zone in which to launch the instances.
	AvailabilityZone *string
	// The location where the instance launched, if applicable.
	Placement *Placement
}

Describes overrides for a launch template.

type FleetLaunchTemplateSpecification 

type FleetLaunchTemplateSpecification struct {
	// 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
	// The ID of the launch template. If you specify the template ID, you can't specify
	// the template name.
	LaunchTemplateId *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 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
	// The name of the launch template. If you specify the template name, you can't
	// specify the template ID.
	LaunchTemplateName *string
	// The ID of the launch template. If you specify the template ID, you can't specify
	// the template name.
	LaunchTemplateId *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 Elastic Compute Cloud User Guide.

type FleetOnDemandAllocationStrategy 

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

Enum values for FleetOnDemandAllocationStrategy

type FleetStateCode 

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

Enum values for FleetStateCode

type FleetType 

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

Enum values for FleetType

type FlowLog 

type FlowLog struct {
	// 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 ID of the resource on which the flow log was created.
	ResourceId *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
	// The ARN of the IAM role that posts logs to CloudWatch Logs.
	DeliverLogsPermissionArn *string
	// The tags for the flow log.
	Tags []*Tag
	// The flow log ID.
	FlowLogId *string
	// The date and time the flow log was created.
	CreationTime *time.Time
	// The type of traffic captured for the flow log.
	TrafficType TrafficType
	// The status of the logs delivery (SUCCESS | FAILED).
	DeliverLogsStatus *string
	// The name of the flow log group.
	LogGroupName *string
	// The status of the flow log (ACTIVE).
	FlowLogStatus *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 format of the flow log record.
	LogFormat *string
	// 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
}

Describes a flow log.

type FlowLogsResourceType 

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

Enum values for FlowLogsResourceType

type FpgaDeviceInfo 

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

Describes the FPGA accelerator for the instance type.

type FpgaDeviceMemoryInfo 

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

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

type FpgaImage 

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

Describes an Amazon FPGA image (AFI).

type FpgaImageAttribute 

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

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

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

type FpgaInfo 

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

Describes the FPGAs for the instance type.

type GatewayType 

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

Enum values for GatewayType

type GpuDeviceInfo 

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

Describes the GPU accelerators for the instance type.

type GpuDeviceMemoryInfo 

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

Describes the memory available to the GPU accelerator.

type GpuInfo 

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

Describes the GPU accelerators for the instance type.

type GroupIdentifier 

type GroupIdentifier struct {
	// The name of the security group.
	GroupName *string
	// The ID of the security group.
	GroupId *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 Elastic Compute Cloud 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 Elastic Compute Cloud User Guide.

type HistoryRecord 

type HistoryRecord struct {
	// The date and time of the event, in UTC format (for example,
	// YYYY-MM-DDTHH:MM:SSZ).
	Timestamp *time.Time
	// 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
}

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

Describes the properties of the Dedicated Host.

type HostInstance 

type HostInstance struct {
	// The instance type (for example, m3.medium) of the running instance.
	InstanceType *string
	// The ID of instance that is running on the Dedicated Host.
	InstanceId *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 upfront price of the offering. Does not apply to No Upfront offerings.
	UpfrontPrice *string
	// The duration of the offering (in seconds).
	Duration *int32
	// The currency of the offering.
	CurrencyCode CurrencyCodeValues
	// The hourly price of the offering.
	HourlyPrice *string
	// The available payment option.
	PaymentOption PaymentOption
	// The instance family of the offering.
	InstanceFamily *string
	// The ID of the offering.
	OfferingId *string
}

Details about the Dedicated Host Reservation offering.

type HostProperties 

type HostProperties struct {
	// 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 instance family supported by the Dedicated Host. For example, m5.
	InstanceFamily *string
	// The total number of vCPUs on the Dedicated Host.
	TotalVCpus *int32
	// The number of cores on the Dedicated Host.
	Cores *int32
}

Describes the properties of a Dedicated Host.

type HostRecovery 

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

Enum values for HostRecovery

type HostReservation 

type HostReservation struct {
	// The state of the reservation.
	State ReservationState
	// Any tags assigned to the Dedicated Host Reservation.
	Tags []*Tag
	// The number of Dedicated Hosts the reservation is associated with.
	Count *int32
	// 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 length of the reservation's term, specified in seconds. Can be 31536000 (1
	// year) | 94608000 (3 years).
	Duration *int32
	// The upfront price of the reservation.
	UpfrontPrice *string
	// The date and time that the reservation started.
	Start *time.Time
	// 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 hourly price of the reservation.
	HourlyPrice *string
	// The date and time that the reservation ends.
	End *time.Time
	// The IDs of the Dedicated Hosts associated with the reservation.
	HostIdSet []*string
	// The currency in which the upfrontPrice and hourlyPrice amounts are specified. At
	// this time, the only supported currency is USD.
	CurrencyCode CurrencyCodeValues
	// The ID of the reservation that specifies the associated Dedicated Hosts.
	HostReservationId *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

type HttpTokensState 

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

Enum values for HttpTokensState

type HypervisorType 

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

Enum values for HypervisorType

type IKEVersionsListValue 

type IKEVersionsListValue struct {
	// The IKE version.
	Value *string
}

The internet key exchange (IKE) version permitted for the VPN tunnel.

type IKEVersionsRequestListValue 

type IKEVersionsRequestListValue struct {
	// The IKE version.
	Value *string
}

The IKE version that is permitted for the VPN tunnel.

type IamInstanceProfile 

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

Describes an IAM instance profile.

type IamInstanceProfileAssociation 

type IamInstanceProfileAssociation struct {
	// The ID of the instance.
	InstanceId *string
	// The time the IAM instance profile was associated with the instance.
	Timestamp *time.Time
	// The state of the association.
	State IamInstanceProfileAssociationState
	// The ID of the association.
	AssociationId *string
	// The IAM instance profile.
	IamInstanceProfile *IamInstanceProfile
}

Describes an association between an IAM instance profile and an instance.

type IamInstanceProfileAssociationState 

type IamInstanceProfileAssociationState string
const (
	IamInstanceProfileAssociationStateAssociating    IamInstanceProfileAssociationState = "associating"
	IamInstanceProfileAssociationStateAssociated     IamInstanceProfileAssociationState = "associated"
	IamInstanceProfileAssociationStateDisassociating IamInstanceProfileAssociationState = "disassociating"
	IamInstanceProfileAssociationStateDisassociated  IamInstanceProfileAssociationState = "disassociated"
)

Enum values for IamInstanceProfileAssociationState

type IamInstanceProfileSpecification 

type IamInstanceProfileSpecification struct {
	// The name of the instance profile.
	Name *string
	// The Amazon Resource Name (ARN) of the instance profile.
	Arn *string
}

Describes an IAM instance profile.

type IcmpTypeCode 

type IcmpTypeCode struct {
	// The ICMP type. A value of -1 means all types.
	Type *int32
	// The ICMP code. A value of -1 means all codes for the specified ICMP type.
	Code *int32
}

Describes the ICMP type and code.

type IdFormat 

type IdFormat struct {
	// The date in UTC at which you are permanently switched over to using longer IDs.
	// If a deadline is not yet available for this resource type, this field is not
	// returned.
	Deadline *time.Time
	// Indicates whether longer IDs (17-character IDs) are enabled for the resource.
	UseLongIds *bool
	// The type of resource.
	Resource *string
}

Describes the ID format for a resource.

type Image 

type Image struct {
	// Specifies whether enhanced networking with ENA is enabled.
	EnaSupport *bool
	// The type of image.
	ImageType ImageTypeValues
	// This value is set to windows for Windows AMIs; otherwise, it is blank.
	Platform PlatformValues
	// The reason for the state change.
	StateReason *StateReason
	// The operation of the Amazon EC2 instance and the billing code that is associated
	// with the AMI. usageOperation corresponds to the lineitem/Operation
	// (https://docs.aws.amazon.com/cur/latest/userguide/Lineitem-columns.html#Lineitem-details-O-Operation)
	// column on your AWS Cost and Usage Report and in the AWS Price List API
	// (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/price-changes.html).
	// For the list of UsageOperation codes, see Platform Details and Usage Operation
	// Billing Codes
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-billing-info.html#billing-info)
	// in the Amazon Elastic Compute Cloud User Guide.
	UsageOperation *string
	// The AWS account ID of the image owner.
	OwnerId *string
	// The location of the AMI.
	ImageLocation *string
	// The AWS account alias (for example, amazon, self) or the AWS account ID of the
	// AMI owner.
	ImageOwnerAlias *string
	// The date and time the image was created.
	CreationDate *string
	// The description of the AMI that was provided during image creation.
	Description *string
	// The device name of the root device volume (for example, /dev/sda1).
	RootDeviceName *string
	// The kernel associated with the image, if any. Only applicable for machine
	// images.
	KernelId *string
	// Indicates whether the image has public launch permissions. The value is true if
	// this image has public launch permissions or false if it has only implicit and
	// explicit launch permissions.
	Public *bool
	// The type of virtualization of the AMI.
	VirtualizationType VirtualizationType
	// The platform details associated with the billing code of the AMI. For more
	// information, see Obtaining Billing Information
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-billing-info.html) in
	// the Amazon Elastic Compute Cloud User Guide.
	PlatformDetails *string
	// The ID of the AMI.
	ImageId *string
	// The name of the AMI that was provided during image creation.
	Name *string
	// The hypervisor type of the image.
	Hypervisor HypervisorType
	// The type of root device used by the AMI. The AMI can use an EBS volume or an
	// instance store volume.
	RootDeviceType DeviceType
	// The architecture of the image.
	Architecture ArchitectureValues
	// Any product codes associated with the AMI.
	ProductCodes []*ProductCode
	// Any block device mapping entries.
	BlockDeviceMappings []*BlockDeviceMapping
	// The current state of the AMI. If the state is available, the image is
	// successfully registered and can be used to launch an instance.
	State ImageState
	// Any tags assigned to the image.
	Tags []*Tag
	// Specifies whether enhanced networking with the Intel 82599 Virtual Function
	// interface is enabled.
	SriovNetSupport *string
	// The RAM disk associated with the image, if any. Only applicable for machine
	// images.
	RamdiskId *string
}

Describes an image.

type ImageAttributeName 

type ImageAttributeName string
const (
	ImageAttributeNameDescription        ImageAttributeName = "description"
	ImageAttributeNameKernel             ImageAttributeName = "kernel"
	ImageAttributeNameRamdisk            ImageAttributeName = "ramdisk"
	ImageAttributeNameLaunchpermission   ImageAttributeName = "launchPermission"
	ImageAttributeNameProductcodes       ImageAttributeName = "productCodes"
	ImageAttributeNameBlockdevicemapping ImageAttributeName = "blockDeviceMapping"
	ImageAttributeNameSriovnetsupport    ImageAttributeName = "sriovNetSupport"
)

Enum values for ImageAttributeName

type ImageDiskContainer 

type ImageDiskContainer struct {
	// The URL to the Amazon S3-based disk image being imported. The URL can either be
	// a https URL (https://..) or an Amazon S3 URL (s3://..)
	Url *string
	// The ID of the EBS snapshot to be used for importing the snapshot.
	SnapshotId *string
	// The format of the disk image being imported. Valid values: OVA | VHD | VHDX
	// |VMDK
	Format *string
	// The description of the disk image.
	Description *string
	// The block device mapping for the disk.
	DeviceName *string
	// The S3 bucket for the disk image.
	UserBucket *UserBucket
}

Describes the disk container object for an import image task.

type ImageState 

type ImageState string
const (
	ImageStatePending      ImageState = "pending"
	ImageStateAvailable    ImageState = "available"
	ImageStateInvalid      ImageState = "invalid"
	ImageStateDeregistered ImageState = "deregistered"
	ImageStateTransient    ImageState = "transient"
	ImageStateFailed       ImageState = "failed"
	ImageStateError        ImageState = "error"
)

Enum values for ImageState

type ImageTypeValues 

type ImageTypeValues string
const (
	ImageTypeValuesMachine ImageTypeValues = "machine"
	ImageTypeValuesKernel  ImageTypeValues = "kernel"
	ImageTypeValuesRamdisk ImageTypeValues = "ramdisk"
)

Enum values for ImageTypeValues

type ImportImageLicenseConfigurationRequest 

type ImportImageLicenseConfigurationRequest struct {
	// The ARN of a license configuration.
	LicenseConfigurationArn *string
}

The request information of license configurations.

type ImportImageLicenseConfigurationResponse 

type ImportImageLicenseConfigurationResponse struct {
	// The ARN of a license configuration.
	LicenseConfigurationArn *string
}

The response information for license configurations.

type ImportImageTask 

type ImportImageTask struct {
	// A brief status for the import image task.
	Status *string
	// A description of the import task.
	Description *string
	// The ID of the Amazon Machine Image (AMI) of the imported virtual machine.
	ImageId *string
	// The architecture of the virtual machine. Valid values: i386 | x86_64 | arm64
	Architecture *string
	// The tags for the import image task.
	Tags []*Tag
	// The ARNs of the license configurations that are associated with the import image
	// task.
	LicenseSpecifications []*ImportImageLicenseConfigurationResponse
	// The ID of the import image task.
	ImportTaskId *string
	// The license type of the virtual machine.
	LicenseType *string
	// The description string for the import image task.
	Platform *string
	// Indicates whether the image is encrypted.
	Encrypted *bool
	// The identifier for the AWS Key Management Service (AWS KMS) customer master key
	// (CMK) that was used to create the encrypted image.
	KmsKeyId *string
	// The percentage of progress of the import image task.
	Progress *string
	// A descriptive status message for the import image task.
	StatusMessage *string
	// Information about the snapshots.
	SnapshotDetails []*SnapshotDetail
	// The target hypervisor for the import task. Valid values: xen
	Hypervisor *string
}

Describes an import image task.

type ImportInstanceLaunchSpecification 

type ImportInstanceLaunchSpecification struct {
	// Indicates whether monitoring is enabled.
	Monitoring *bool
	// [EC2-VPC] An available IP address from the IP address range of the subnet.
	PrivateIpAddress *string
	// The instance type. For more information about the instance types that you can
	// import, see Instance Types
	// (https://docs.aws.amazon.com/vm-import/latest/userguide/vmie_prereqs.html#vmimport-instance-types)
	// in the VM Import/Export User Guide.
	InstanceType InstanceType
	// The Base64-encoded user data to make available to the instance.
	UserData *UserData
	// The security group IDs.
	GroupIds []*string
	// Indicates whether an instance stops or terminates when you initiate shutdown
	// from the instance (using the operating system command for system shutdown).
	InstanceInitiatedShutdownBehavior ShutdownBehavior
	// The architecture of the instance.
	Architecture ArchitectureValues
	// The placement information for the instance.
	Placement *Placement
	// [EC2-VPC] The ID of the subnet in which to launch the instance.
	SubnetId *string
	// Reserved.
	AdditionalInfo *string
	// The security group names.
	GroupNames []*string
}

Describes the launch specification for VM import.

type ImportInstanceTaskDetails 

type ImportInstanceTaskDetails struct {
	// The instance operating system.
	Platform PlatformValues
	// A description of the task.
	Description *string
	// The volumes.
	Volumes []*ImportInstanceVolumeDetailItem
	// The ID of the instance.
	InstanceId *string
}

Describes an import instance task.

type ImportInstanceVolumeDetailItem 

type ImportInstanceVolumeDetailItem struct {
	// The status information or errors related to the disk image.
	StatusMessage *string
	// The Availability Zone where the resulting instance will reside.
	AvailabilityZone *string
	// A description of the task.
	Description *string
	// The number of bytes converted so far.
	BytesConverted *int64
	// The status of the import of this particular disk image.
	Status *string
	// The volume.
	Volume *DiskImageVolumeDescription
	// The image.
	Image *DiskImageDescription
}

Describes an import volume task.

type ImportSnapshotTask 

type ImportSnapshotTask struct {
	// The ID of the import snapshot task.
	ImportTaskId *string
	// The tags for the import snapshot task.
	Tags []*Tag
	// Describes an import snapshot task.
	SnapshotTaskDetail *SnapshotTaskDetail
	// A description of the import snapshot task.
	Description *string
}

Describes an import snapshot task.

type ImportVolumeTaskDetails 

type ImportVolumeTaskDetails struct {
	// The image.
	Image *DiskImageDescription
	// The number of bytes converted so far.
	BytesConverted *int64
	// The description you provided when starting the import volume task.
	Description *string
	// The Availability Zone where the resulting volume will reside.
	AvailabilityZone *string
	// The volume.
	Volume *DiskImageVolumeDescription
}

Describes an import volume task.

type InferenceAcceleratorInfo 

type InferenceAcceleratorInfo struct {
	// Describes the Inference accelerators for the instance type.
	Accelerators []*InferenceDeviceInfo
}

Describes the Inference accelerators for the instance type.

type InferenceDeviceInfo 

type InferenceDeviceInfo struct {
	// The manufacturer of the Inference accelerator.
	Manufacturer *string
	// The number of Inference accelerators for the instance type.
	Count *int32
	// The name of the Inference accelerator.
	Name *string
}

Describes the Inference accelerators for the instance type.

type Instance 

type Instance struct {
	// The ID of the Capacity Reservation.
	CapacityReservationId *string
	// The IAM instance profile associated with the instance, if applicable.
	IamInstanceProfile *IamInstanceProfile
	// The current state of the instance.
	State *InstanceState
	// The security groups for the instance.
	SecurityGroups []*GroupIdentifier
	// The idempotency token you provided when you launched the instance, if
	// applicable.
	ClientToken *string
	// If the request is a Spot Instance request, the ID of the request.
	SpotInstanceRequestId *string
	// The license configurations.
	Licenses []*LicenseConfiguration
	// Any tags assigned to the instance.
	Tags []*Tag
	// (IPv4 only) The public DNS name assigned to the instance. This name is not
	// available until the instance enters the running state. For EC2-VPC, this name is
	// only available if you've enabled DNS hostnames for your VPC.
	PublicDnsName *string
	// The product codes attached to this instance, if applicable.
	ProductCodes []*ProductCode
	// The ID of the instance.
	InstanceId *string
	// The reason for the most recent state transition.
	StateReason *StateReason
	// The reason for the most recent state transition. This might be an empty string.
	StateTransitionReason *string
	// The metadata options for the instance.
	MetadataOptions *InstanceMetadataOptionsResponse
	// Specifies whether enhanced networking with ENA is enabled.
	EnaSupport *bool
	// [EC2-VPC] The ID of the VPC in which the instance is running.
	VpcId *string
	// Any block device mapping entries for the instance.
	BlockDeviceMappings []*InstanceBlockDeviceMapping
	// Indicates whether the instance is optimized for Amazon EBS I/O. 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 Elastic GPU associated with the instance.
	ElasticGpuAssociations []*ElasticGpuAssociation
	// The RAM disk associated with this instance, if applicable.
	RamdiskId *string
	// Specifies whether enhanced networking with the Intel 82599 Virtual Function
	// interface is enabled.
	SriovNetSupport *string
	// [EC2-VPC] The network interfaces for the instance.
	NetworkInterfaces []*InstanceNetworkInterface
	// The name of the key pair, if this instance was launched with an associated key
	// pair.
	KeyName *string
	// The ID of the AMI used to launch the instance.
	ImageId *string
	// Specifies whether to enable an instance launched in a VPC to perform NAT. This
	// controls whether source/destination checking is enabled on the instance. A value
	// of true means that checking is enabled, and false means that checking is
	// disabled. The value must be false for the instance to perform NAT. For more
	// information, see NAT Instances
	// (https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html)
	// in the Amazon Virtual Private Cloud User Guide.
	SourceDestCheck *bool
	// The private IPv4 address assigned to the instance.
	PrivateIpAddress *string
	// The AMI launch index, which can be used to find this instance in the launch
	// group.
	AmiLaunchIndex *int32
	// The root device type used by the AMI. The AMI can use an EBS volume or an
	// instance store volume.
	RootDeviceType DeviceType
	// The elastic inference accelerator associated with the instance.
	ElasticInferenceAcceleratorAssociations []*ElasticInferenceAcceleratorAssociation
	// [EC2-VPC] The ID of the subnet in which the instance is running.
	SubnetId *string
	// Indicates whether the instance is enabled for hibernation.
	HibernationOptions *HibernationOptions
	// The kernel associated with this instance, if applicable.
	KernelId *string
	// The value is Windows for Windows instances; otherwise blank.
	Platform PlatformValues
	// The instance type.
	InstanceType InstanceType
	// Indicates whether this is a Spot Instance or a Scheduled Instance.
	InstanceLifecycle InstanceLifecycleType
	// The hypervisor type of the instance. The value xen is used for both Xen and
	// Nitro hypervisors.
	Hypervisor HypervisorType
	// (IPv4 only) The private DNS hostname name assigned to the instance. This DNS
	// hostname can only be used inside the Amazon EC2 network. This name is not
	// available until the instance enters the running state. [EC2-VPC] The
	// Amazon-provided DNS server resolves Amazon-provided private DNS hostnames if
	// you've enabled DNS resolution and DNS hostnames in your VPC. If you are not
	// using the Amazon-provided DNS server in your VPC, your custom domain name
	// servers must resolve the hostname as appropriate.
	PrivateDnsName *string
	// The CPU options for the instance.
	CpuOptions *CpuOptions
	// The time the instance was launched.
	LaunchTime *time.Time
	// Information about the Capacity Reservation targeting option.
	CapacityReservationSpecification *CapacityReservationSpecificationResponse
	// The location where the instance launched, if applicable.
	Placement *Placement
	// The virtualization type of the instance.
	VirtualizationType VirtualizationType
	// The Amazon Resource Name (ARN) of the Outpost.
	OutpostArn *string
	// The monitoring for the instance.
	Monitoring *Monitoring
	// The public IPv4 address assigned to the instance, if applicable.
	PublicIpAddress *string
	// The architecture of the image.
	Architecture ArchitectureValues
	// The device name of the root device volume (for example, /dev/sda1).
	RootDeviceName *string
}

Describes an instance.

type InstanceAttributeName 

type InstanceAttributeName string
const (
	InstanceAttributeNameInstancetype                      InstanceAttributeName = "instanceType"
	InstanceAttributeNameKernel                            InstanceAttributeName = "kernel"
	InstanceAttributeNameRamdisk                           InstanceAttributeName = "ramdisk"
	InstanceAttributeNameUserdata                          InstanceAttributeName = "userData"
	InstanceAttributeNameDisableapitermination             InstanceAttributeName = "disableApiTermination"
	InstanceAttributeNameInstanceinitiatedshutdownbehavior InstanceAttributeName = "instanceInitiatedShutdownBehavior"
	InstanceAttributeNameRootdevicename                    InstanceAttributeName = "rootDeviceName"
	InstanceAttributeNameBlockdevicemapping                InstanceAttributeName = "blockDeviceMapping"
	InstanceAttributeNameProductcodes                      InstanceAttributeName = "productCodes"
	InstanceAttributeNameSourcedestcheck                   InstanceAttributeName = "sourceDestCheck"
	InstanceAttributeNameGroupset                          InstanceAttributeName = "groupSet"
	InstanceAttributeNameEbsoptimized                      InstanceAttributeName = "ebsOptimized"
	InstanceAttributeNameSriovnetsupport                   InstanceAttributeName = "sriovNetSupport"
	InstanceAttributeNameEnasupport                        InstanceAttributeName = "enaSupport"
)

Enum values for InstanceAttributeName

type InstanceBlockDeviceMapping 

type InstanceBlockDeviceMapping 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 *EbsInstanceBlockDevice
}

Describes a block device mapping.

type InstanceBlockDeviceMappingSpecification 

type InstanceBlockDeviceMappingSpecification struct {
	// The virtual device name.
	VirtualName *string
	// Parameters used to automatically set up EBS volumes when the instance is
	// launched.
	Ebs *EbsInstanceBlockDeviceSpecification
	// suppress the specified device included in the block device mapping.
	NoDevice *string
	// The device name (for example, /dev/sdh or xvdh).
	DeviceName *string
}

Describes a block device mapping entry.

type InstanceCapacity 

type InstanceCapacity struct {
	// The number of instances that can be launched onto the Dedicated Host based on
	// the host's available capacity.
	AvailableCapacity *int32
	// The total number of instances that can be launched onto the Dedicated Host if
	// there are no instances running on it.
	TotalCapacity *int32
	// The instance type supported by the Dedicated Host.
	InstanceType *string
}

Information about the number of instances that can be launched onto the Dedicated Host.

type InstanceCount 

type InstanceCount struct {
	// The states of the listed Reserved Instances.
	State ListingState
	// The number of listed Reserved Instances in the state specified by the state.
	InstanceCount *int32
}

Describes a Reserved Instance listing state.

type InstanceCreditSpecification 

type InstanceCreditSpecification struct {
	// The ID of the instance.
	InstanceId *string
	// The credit option for CPU usage of the instance. Valid values are standard and
	// unlimited.
	CpuCredits *string
}

Describes the credit option for CPU usage of a burstable performance instance.

type InstanceCreditSpecificationRequest 

type InstanceCreditSpecificationRequest struct {
	// The ID of the instance.
	InstanceId *string
	// The credit option for CPU usage of the instance. Valid values are standard and
	// unlimited.
	CpuCredits *string
}

Describes the credit option for CPU usage of a burstable performance instance.

type InstanceExportDetails 

type InstanceExportDetails struct {
	// The ID of the resource being exported.
	InstanceId *string
	// The target virtualization environment.
	TargetEnvironment ExportEnvironment
}

Describes an instance to export.

type InstanceFamilyCreditSpecification 

type InstanceFamilyCreditSpecification struct {
	// The instance family.
	InstanceFamily UnlimitedSupportedInstanceFamily
	// The default credit option for CPU usage of the instance family. Valid values are
	// standard and unlimited.
	CpuCredits *string
}

Describes the default credit option for CPU usage of a burstable performance instance family.

type InstanceHealthStatus 

type InstanceHealthStatus string
const (
	InstanceHealthStatusHealthy_status   InstanceHealthStatus = "healthy"
	InstanceHealthStatusUnhealthy_status InstanceHealthStatus = "unhealthy"
)

Enum values for InstanceHealthStatus

type InstanceInterruptionBehavior 

type InstanceInterruptionBehavior string
const (
	InstanceInterruptionBehaviorHibernate InstanceInterruptionBehavior = "hibernate"
	InstanceInterruptionBehaviorStop      InstanceInterruptionBehavior = "stop"
	InstanceInterruptionBehaviorTerminate InstanceInterruptionBehavior = "terminate"
)

Enum values for InstanceInterruptionBehavior

type InstanceIpv6Address 

type InstanceIpv6Address struct {
	// The IPv6 address.
	Ipv6Address *string
}

Describes an IPv6 address.

type InstanceIpv6AddressRequest 

type InstanceIpv6AddressRequest struct {
	// The IPv6 address.
	Ipv6Address *string
}

Describes an IPv6 address.

type InstanceLifecycle 

type InstanceLifecycle string
const (
	InstanceLifecycleSpot      InstanceLifecycle = "spot"
	InstanceLifecycleOn_demand InstanceLifecycle = "on-demand"
)

Enum values for InstanceLifecycle

type InstanceLifecycleType 

type InstanceLifecycleType string
const (
	InstanceLifecycleTypeSpot      InstanceLifecycleType = "spot"
	InstanceLifecycleTypeScheduled InstanceLifecycleType = "scheduled"
)

Enum values for InstanceLifecycleType

type InstanceMarketOptionsRequest 

type InstanceMarketOptionsRequest struct {
	// The options for Spot Instances.
	SpotOptions *SpotMarketOptions
	// The market type.
	MarketType MarketType
}

Describes the market (purchasing) option for the instances.

type InstanceMatchCriteria 

type InstanceMatchCriteria string
const (
	InstanceMatchCriteriaOpen     InstanceMatchCriteria = "open"
	InstanceMatchCriteriaTargeted InstanceMatchCriteria = "targeted"
)

Enum values for InstanceMatchCriteria

type InstanceMetadataEndpointState 

type InstanceMetadataEndpointState string
const (
	InstanceMetadataEndpointStateDisabled InstanceMetadataEndpointState = "disabled"
	InstanceMetadataEndpointStateEnabled  InstanceMetadataEndpointState = "enabled"
)

Enum values for InstanceMetadataEndpointState

type InstanceMetadataOptionsRequest 

type InstanceMetadataOptionsRequest struct {
	// This parameter enables or disables the HTTP metadata endpoint on your instances.
	// If the parameter is not specified, the default state is enabled. If you specify
	// a value of disabled, you will not be able to access your instance metadata.
	HttpEndpoint InstanceMetadataEndpointState
	// The state of token usage for your instance metadata requests. If the parameter
	// is not specified in the request, the default state is optional. If the state is
	// optional, you can choose to retrieve instance metadata with or without a signed
	// token header on your request. If you retrieve the IAM role credentials without a
	// token, the version 1.0 role credentials are returned. If you retrieve the IAM
	// role credentials using a valid signed token, the version 2.0 role credentials
	// are returned. If the state is required, you must send a signed token header with
	// any instance metadata retrieval requests. In this state, retrieving the IAM role
	// credentials always returns the version 2.0 credentials; the version 1.0
	// credentials are not available.
	HttpTokens HttpTokensState
	// The desired HTTP PUT response hop limit for instance metadata requests. The
	// larger the number, the further instance metadata requests can travel. Default: 1
	// Possible values: Integers from 1 to 64
	HttpPutResponseHopLimit *int32
}

The metadata options for the instance.

type InstanceMetadataOptionsResponse 

type InstanceMetadataOptionsResponse struct {
	// The desired HTTP PUT response hop limit for instance metadata requests. The
	// larger the number, the further instance metadata requests can travel. Default: 1
	// Possible values: Integers from 1 to 64
	HttpPutResponseHopLimit *int32
	// The state of the metadata option changes. pending - The metadata options are
	// being updated and the instance is not ready to process metadata traffic with the
	// new selection. applied - The metadata options have been successfully applied on
	// the instance.
	State InstanceMetadataOptionsState
	// The state of token usage for your instance metadata requests. If the parameter
	// is not specified in the request, the default state is optional. If the state is
	// optional, you can choose to retrieve instance metadata with or without a signed
	// token header on your request. If you retrieve the IAM role credentials without a
	// token, the version 1.0 role credentials are returned. If you retrieve the IAM
	// role credentials using a valid signed token, the version 2.0 role credentials
	// are returned. If the state is required, you must send a signed token header with
	// any instance metadata retrieval requests. In this state, retrieving the IAM role
	// credential always returns the version 2.0 credentials; the version 1.0
	// credentials are not available.
	HttpTokens HttpTokensState
	// This parameter enables or disables the HTTP metadata endpoint on your instances.
	// If the parameter is not specified, the default state is enabled. If you specify
	// a value of disabled, you will not be able to access your instance metadata.
	HttpEndpoint InstanceMetadataEndpointState
}

The metadata options for the instance.

type InstanceMetadataOptionsState 

type InstanceMetadataOptionsState string
const (
	InstanceMetadataOptionsStatePending InstanceMetadataOptionsState = "pending"
	InstanceMetadataOptionsStateApplied InstanceMetadataOptionsState = "applied"
)

Enum values for InstanceMetadataOptionsState

type InstanceMonitoring 

type InstanceMonitoring struct {
	// The monitoring for the instance.
	Monitoring *Monitoring
	// The ID of the instance.
	InstanceId *string
}

Describes the monitoring of an instance.

type InstanceNetworkInterface 

type InstanceNetworkInterface struct {
	// The association information for an Elastic IPv4 associated with the network
	// interface.
	Association *InstanceNetworkInterfaceAssociation
	// One or more private IPv4 addresses associated with the network interface.
	PrivateIpAddresses []*InstancePrivateIpAddress
	// The ID of the network interface.
	NetworkInterfaceId *string
	// The ID of the subnet.
	SubnetId *string
	// The status of the network interface.
	Status NetworkInterfaceStatus
	// The network interface attachment.
	Attachment *InstanceNetworkInterfaceAttachment
	// The ID of the AWS account that created the network interface.
	OwnerId *string
	// One or more IPv6 addresses associated with the network interface.
	Ipv6Addresses []*InstanceIpv6Address
	// The IPv4 address of the network interface within the subnet.
	PrivateIpAddress *string
	// The private DNS name.
	PrivateDnsName *string
	// The MAC address.
	MacAddress *string
	// Indicates whether to validate network traffic to or from this network interface.
	SourceDestCheck *bool
	// One or more security groups.
	Groups []*GroupIdentifier
	// The description.
	Description *string
	// The ID of the VPC.
	VpcId *string
	// Describes the type of network interface. Valid values: interface | efa
	InterfaceType *string
}

Describes a network interface.

type InstanceNetworkInterfaceAssociation 

type InstanceNetworkInterfaceAssociation struct {
	// The public IP address or Elastic IP address bound to the network interface.
	PublicIp *string
	// The public DNS name.
	PublicDnsName *string
	// The ID of the owner of the Elastic IP address.
	IpOwnerId *string
}

Describes association information for an Elastic IP address (IPv4).

type InstanceNetworkInterfaceAttachment 

type InstanceNetworkInterfaceAttachment struct {
	// The ID of the network interface attachment.
	AttachmentId *string
	// The attachment state.
	Status AttachmentStatus
	// Indicates whether the network interface is deleted when the instance is
	// terminated.
	DeleteOnTermination *bool
	// The index of the device on the instance for the network interface attachment.
	DeviceIndex *int32
	// The time stamp when the attachment initiated.
	AttachTime *time.Time
}

Describes a network interface attachment.

type InstanceNetworkInterfaceSpecification 

type InstanceNetworkInterfaceSpecification struct {
	// If set to true, the interface is deleted when the instance is terminated. You
	// can specify true only if creating a new network interface when launching an
	// instance.
	DeleteOnTermination *bool
	// The private IPv4 address of the network interface. Applies only if creating a
	// network interface when launching an instance. You cannot specify this option if
	// you're launching more than one instance in a RunInstances
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)
	// request.
	PrivateIpAddress *string
	// The position of the network interface in the attachment order. A primary network
	// interface has a device index of 0. If you specify a network interface when
	// launching an instance, you must specify the device index.
	DeviceIndex *int32
	// One or more IPv6 addresses to assign to the network interface. You cannot
	// specify this option and the option to assign a number of IPv6 addresses in the
	// same request. You cannot specify this option if you've specified a minimum
	// number of instances to launch.
	Ipv6Addresses []*InstanceIpv6Address
	// The number of secondary private IPv4 addresses. You can't specify this option
	// and specify more than one private IP address using the private IP addresses
	// option. You cannot specify this option if you're launching more than one
	// instance in a RunInstances
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)
	// request.
	SecondaryPrivateIpAddressCount *int32
	// The ID of the network interface. If you are creating a Spot Fleet, omit this
	// parameter because you can’t specify a network interface ID in a launch
	// specification.
	NetworkInterfaceId *string
	// The type of network interface. To create an Elastic Fabric Adapter (EFA),
	// specify efa. For more information, see Elastic Fabric Adapter
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) in the Amazon
	// Elastic Compute Cloud User Guide. If you are not creating an EFA, specify
	// interface or omit this parameter. Valid values: interface | efa
	InterfaceType *string
	// One or more private IPv4 addresses to assign to the network interface. Only one
	// private IPv4 address can be designated as primary. You cannot specify this
	// option if you're launching more than one instance in a RunInstances
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)
	// request.
	PrivateIpAddresses []*PrivateIpAddressSpecification
	// The ID of the subnet associated with the network interface. Applies only if
	// creating a network interface when launching an instance.
	SubnetId *string
	// The description of the network interface. Applies only if creating a network
	// interface when launching an instance.
	Description *string
	// The IDs of the security groups for the network interface. Applies only if
	// creating a network interface when launching an instance.
	Groups []*string
	// A number of IPv6 addresses to assign to the network interface. Amazon EC2
	// chooses the IPv6 addresses from the range of the subnet. You cannot specify this
	// option and the option to assign specific IPv6 addresses in the same request. You
	// can specify this option if you've specified a minimum number of instances to
	// launch.
	Ipv6AddressCount *int32
	// Indicates whether to assign a public IPv4 address to an instance you launch in a
	// VPC. The public IP address can only be assigned to a network interface for eth0,
	// and can only be assigned to a new network interface, not an existing one. You
	// cannot specify more than one network interface in the request. If launching into
	// a default subnet, the default value is true.
	AssociatePublicIpAddress *bool
}

Describes a network interface.

type InstancePrivateIpAddress 

type InstancePrivateIpAddress struct {
	// The private IPv4 address of the network interface.
	PrivateIpAddress *string
	// Indicates whether this IPv4 address is the primary private IP address of the
	// network interface.
	Primary *bool
	// The private IPv4 DNS name.
	PrivateDnsName *string
	// The association information for an Elastic IP address for the network interface.
	Association *InstanceNetworkInterfaceAssociation
}

Describes a private IPv4 address.

type InstanceSpecification 

type InstanceSpecification struct {
	// The instance to specify which volumes should be snapshotted.
	InstanceId *string
	// Excludes the root volume from being snapshotted.
	ExcludeBootVolume *bool
}

The instance details to specify which volumes should be snapshotted.

type InstanceState 

type InstanceState struct {
	// The current state of the instance.
	Name InstanceStateName
	// The state of the instance as a 16-bit unsigned integer. The high byte is all of
	// the bits between 2^8 and (2^16)-1, which equals decimal values between 256 and
	// 65,535. These numerical values are used for internal purposes and should be
	// ignored. The low byte is all of the bits between 2^0 and (2^8)-1, which equals
	// decimal values between 0 and 255. The valid values for instance-state-code will
	// all be in the range of the low byte and they are:
	//
	//     * 0 : pending
	//
	//     * 16 :
	// running
	//
	//     * 32 : shutting-down
	//
	//     * 48 : terminated
	//
	//     * 64 : stopping
	//
	//
	// * 80 : stopped
	//
	// You can ignore the high byte value by zeroing out all of the
	// bits above 2^8 or 256 in decimal.
	Code *int32
}

Describes the current state of an instance.

type InstanceStateChange 

type InstanceStateChange struct {
	// The previous state of the instance.
	PreviousState *InstanceState
	// The current state of the instance.
	CurrentState *InstanceState
	// The ID of the instance.
	InstanceId *string
}

Describes an instance state change.

type InstanceStateName 

type InstanceStateName string
const (
	InstanceStateNamePending      InstanceStateName = "pending"
	InstanceStateNameRunning      InstanceStateName = "running"
	InstanceStateNameShuttingDown InstanceStateName = "shutting-down"
	InstanceStateNameTerminated   InstanceStateName = "terminated"
	InstanceStateNameStopping     InstanceStateName = "stopping"
	InstanceStateNameStopped      InstanceStateName = "stopped"
)

Enum values for InstanceStateName

type InstanceStatus 

type InstanceStatus struct {
	// Reports impaired functionality that stems from issues related to the systems
	// that support an instance, such as hardware failures and network connectivity
	// problems.
	SystemStatus *InstanceStatusSummary
	// The Availability Zone of the instance.
	AvailabilityZone *string
	// Reports impaired functionality that stems from issues internal to the instance,
	// such as impaired reachability.
	InstanceStatus *InstanceStatusSummary
	// The ID of the instance.
	InstanceId *string
	// The intended state of the instance. DescribeInstanceStatus () requires that an
	// instance be in the running state.
	InstanceState *InstanceState
	// The Amazon Resource Name (ARN) of the Outpost.
	OutpostArn *string
	// Any scheduled events associated with the instance.
	Events []*InstanceStatusEvent
}

Describes the status of an instance.

type InstanceStatusDetails 

type InstanceStatusDetails struct {
	// The time when a status check failed. For an instance that was launched and
	// impaired, this is the time when the instance was launched.
	ImpairedSince *time.Time
	// The type of instance status.
	Name StatusName
	// The status.
	Status StatusType
}

Describes the instance status.

type InstanceStatusEvent 

type InstanceStatusEvent struct {
	// The event code.
	Code EventCode
	// The deadline for starting the event.
	NotBeforeDeadline *time.Time
	// The latest scheduled end time for the event.
	NotAfter *time.Time
	// A description of the event. After a scheduled event is completed, it can still
	// be described for up to a week. If the event has been completed, this description
	// starts with the following text: [Completed].
	Description *string
	// The earliest scheduled start time for the event.
	NotBefore *time.Time
	// The ID of the event.
	InstanceEventId *string
}

Describes a scheduled event for an instance.

type InstanceStatusSummary 

type InstanceStatusSummary struct {
	// The system instance health or application instance health.
	Details []*InstanceStatusDetails
	// The status.
	Status SummaryStatus
}

Describes the status of an instance.

type InstanceStorageInfo 

type InstanceStorageInfo struct {
	// Array describing the disks that are available for the instance type.
	Disks []*DiskInfo
	// The total size of the disks, in GB.
	TotalSizeInGB *int64
}

Describes the disks that are available for the instance type.

type InstanceTagNotificationAttribute 

type InstanceTagNotificationAttribute struct {
	// The registered tag keys.
	InstanceTagKeys []*string
	// Indicates wheter all tag keys in the current Region are registered to appear in
	// scheduled event notifications. true indicates that all tag keys in the current
	// Region are registered.
	IncludeAllTagsOfInstance *bool
}

Describes the registered tag keys for the current Region.

type InstanceType 

type InstanceType string
const (
	InstanceTypeT1Micro      InstanceType = "t1.micro"
	InstanceTypeT2Nano       InstanceType = "t2.nano"
	InstanceTypeT2Micro      InstanceType = "t2.micro"
	InstanceTypeT2Small      InstanceType = "t2.small"
	InstanceTypeT2Medium     InstanceType = "t2.medium"
	InstanceTypeT2Large      InstanceType = "t2.large"
	InstanceTypeT2Xlarge     InstanceType = "t2.xlarge"
	InstanceTypeT22xlarge    InstanceType = "t2.2xlarge"
	InstanceTypeT3Nano       InstanceType = "t3.nano"
	InstanceTypeT3Micro      InstanceType = "t3.micro"
	InstanceTypeT3Small      InstanceType = "t3.small"
	InstanceTypeT3Medium     InstanceType = "t3.medium"
	InstanceTypeT3Large      InstanceType = "t3.large"
	InstanceTypeT3Xlarge     InstanceType = "t3.xlarge"
	InstanceTypeT32xlarge    InstanceType = "t3.2xlarge"
	InstanceTypeT3aNano      InstanceType = "t3a.nano"
	InstanceTypeT3aMicro     InstanceType = "t3a.micro"
	InstanceTypeT3aSmall     InstanceType = "t3a.small"
	InstanceTypeT3aMedium    InstanceType = "t3a.medium"
	InstanceTypeT3aLarge     InstanceType = "t3a.large"
	InstanceTypeT3aXlarge    InstanceType = "t3a.xlarge"
	InstanceTypeT3a2xlarge   InstanceType = "t3a.2xlarge"
	InstanceTypeM1Small      InstanceType = "m1.small"
	InstanceTypeM1Medium     InstanceType = "m1.medium"
	InstanceTypeM1Large      InstanceType = "m1.large"
	InstanceTypeM1Xlarge     InstanceType = "m1.xlarge"
	InstanceTypeM3Medium     InstanceType = "m3.medium"
	InstanceTypeM3Large      InstanceType = "m3.large"
	InstanceTypeM3Xlarge     InstanceType = "m3.xlarge"
	InstanceTypeM32xlarge    InstanceType = "m3.2xlarge"
	InstanceTypeM4Large      InstanceType = "m4.large"
	InstanceTypeM4Xlarge     InstanceType = "m4.xlarge"
	InstanceTypeM42xlarge    InstanceType = "m4.2xlarge"
	InstanceTypeM44xlarge    InstanceType = "m4.4xlarge"
	InstanceTypeM410xlarge   InstanceType = "m4.10xlarge"
	InstanceTypeM416xlarge   InstanceType = "m4.16xlarge"
	InstanceTypeM2Xlarge     InstanceType = "m2.xlarge"
	InstanceTypeM22xlarge    InstanceType = "m2.2xlarge"
	InstanceTypeM24xlarge    InstanceType = "m2.4xlarge"
	InstanceTypeCr18xlarge   InstanceType = "cr1.8xlarge"
	InstanceTypeR3Large      InstanceType = "r3.large"
	InstanceTypeR3Xlarge     InstanceType = "r3.xlarge"
	InstanceTypeR32xlarge    InstanceType = "r3.2xlarge"
	InstanceTypeR34xlarge    InstanceType = "r3.4xlarge"
	InstanceTypeR38xlarge    InstanceType = "r3.8xlarge"
	InstanceTypeR4Large      InstanceType = "r4.large"
	InstanceTypeR4Xlarge     InstanceType = "r4.xlarge"
	InstanceTypeR42xlarge    InstanceType = "r4.2xlarge"
	InstanceTypeR44xlarge    InstanceType = "r4.4xlarge"
	InstanceTypeR48xlarge    InstanceType = "r4.8xlarge"
	InstanceTypeR416xlarge   InstanceType = "r4.16xlarge"
	InstanceTypeR5Large      InstanceType = "r5.large"
	InstanceTypeR5Xlarge     InstanceType = "r5.xlarge"
	InstanceTypeR52xlarge    InstanceType = "r5.2xlarge"
	InstanceTypeR54xlarge    InstanceType = "r5.4xlarge"
	InstanceTypeR58xlarge    InstanceType = "r5.8xlarge"
	InstanceTypeR512xlarge   InstanceType = "r5.12xlarge"
	InstanceTypeR516xlarge   InstanceType = "r5.16xlarge"
	InstanceTypeR524xlarge   InstanceType = "r5.24xlarge"
	InstanceTypeR5Metal      InstanceType = "r5.metal"
	InstanceTypeR5aLarge     InstanceType = "r5a.large"
	InstanceTypeR5aXlarge    InstanceType = "r5a.xlarge"
	InstanceTypeR5a2xlarge   InstanceType = "r5a.2xlarge"
	InstanceTypeR5a4xlarge   InstanceType = "r5a.4xlarge"
	InstanceTypeR5a8xlarge   InstanceType = "r5a.8xlarge"
	InstanceTypeR5a12xlarge  InstanceType = "r5a.12xlarge"
	InstanceTypeR5a16xlarge  InstanceType = "r5a.16xlarge"
	InstanceTypeR5a24xlarge  InstanceType = "r5a.24xlarge"
	InstanceTypeR5dLarge     InstanceType = "r5d.large"
	InstanceTypeR5dXlarge    InstanceType = "r5d.xlarge"
	InstanceTypeR5d2xlarge   InstanceType = "r5d.2xlarge"
	InstanceTypeR5d4xlarge   InstanceType = "r5d.4xlarge"
	InstanceTypeR5d8xlarge   InstanceType = "r5d.8xlarge"
	InstanceTypeR5d12xlarge  InstanceType = "r5d.12xlarge"
	InstanceTypeR5d16xlarge  InstanceType = "r5d.16xlarge"
	InstanceTypeR5d24xlarge  InstanceType = "r5d.24xlarge"
	InstanceTypeR5dMetal     InstanceType = "r5d.metal"
	InstanceTypeR5adLarge    InstanceType = "r5ad.large"
	InstanceTypeR5adXlarge   InstanceType = "r5ad.xlarge"
	InstanceTypeR5ad2xlarge  InstanceType = "r5ad.2xlarge"
	InstanceTypeR5ad4xlarge  InstanceType = "r5ad.4xlarge"
	InstanceTypeR5ad8xlarge  InstanceType = "r5ad.8xlarge"
	InstanceTypeR5ad12xlarge InstanceType = "r5ad.12xlarge"
	InstanceTypeR5ad16xlarge InstanceType = "r5ad.16xlarge"
	InstanceTypeR5ad24xlarge InstanceType = "r5ad.24xlarge"
	InstanceTypeR6gMetal     InstanceType = "r6g.metal"
	InstanceTypeR6gMedium    InstanceType = "r6g.medium"
	InstanceTypeR6gLarge     InstanceType = "r6g.large"
	InstanceTypeR6gXlarge    InstanceType = "r6g.xlarge"
	InstanceTypeR6g2xlarge   InstanceType = "r6g.2xlarge"
	InstanceTypeR6g4xlarge   InstanceType = "r6g.4xlarge"
	InstanceTypeR6g8xlarge   InstanceType = "r6g.8xlarge"
	InstanceTypeR6g12xlarge  InstanceType = "r6g.12xlarge"
	InstanceTypeR6g16xlarge  InstanceType = "r6g.16xlarge"
	InstanceTypeR6gdMetal    InstanceType = "r6gd.metal"
	InstanceTypeR6gdMedium   InstanceType = "r6gd.medium"
	InstanceTypeR6gdLarge    InstanceType = "r6gd.large"
	InstanceTypeR6gdXlarge   InstanceType = "r6gd.xlarge"
	InstanceTypeR6gd2xlarge  InstanceType = "r6gd.2xlarge"
	InstanceTypeR6gd4xlarge  InstanceType = "r6gd.4xlarge"
	InstanceTypeR6gd8xlarge  InstanceType = "r6gd.8xlarge"
	InstanceTypeR6gd12xlarge InstanceType = "r6gd.12xlarge"
	InstanceTypeR6gd16xlarge InstanceType = "r6gd.16xlarge"
	InstanceTypeX116xlarge   InstanceType = "x1.16xlarge"
	InstanceTypeX132xlarge   InstanceType = "x1.32xlarge"
	InstanceTypeX1eXlarge    InstanceType = "x1e.xlarge"
	InstanceTypeX1e2xlarge   InstanceType = "x1e.2xlarge"
	InstanceTypeX1e4xlarge   InstanceType = "x1e.4xlarge"
	InstanceTypeX1e8xlarge   InstanceType = "x1e.8xlarge"
	InstanceTypeX1e16xlarge  InstanceType = "x1e.16xlarge"
	InstanceTypeX1e32xlarge  InstanceType = "x1e.32xlarge"
	InstanceTypeI2Xlarge     InstanceType = "i2.xlarge"
	InstanceTypeI22xlarge    InstanceType = "i2.2xlarge"
	InstanceTypeI24xlarge    InstanceType = "i2.4xlarge"
	InstanceTypeI28xlarge    InstanceType = "i2.8xlarge"
	InstanceTypeI3Large      InstanceType = "i3.large"
	InstanceTypeI3Xlarge     InstanceType = "i3.xlarge"
	InstanceTypeI32xlarge    InstanceType = "i3.2xlarge"
	InstanceTypeI34xlarge    InstanceType = "i3.4xlarge"
	InstanceTypeI38xlarge    InstanceType = "i3.8xlarge"
	InstanceTypeI316xlarge   InstanceType = "i3.16xlarge"
	InstanceTypeI3Metal      InstanceType = "i3.metal"
	InstanceTypeI3enLarge    InstanceType = "i3en.large"
	InstanceTypeI3enXlarge   InstanceType = "i3en.xlarge"
	InstanceTypeI3en2xlarge  InstanceType = "i3en.2xlarge"
	InstanceTypeI3en3xlarge  InstanceType = "i3en.3xlarge"
	InstanceTypeI3en6xlarge  InstanceType = "i3en.6xlarge"
	InstanceTypeI3en12xlarge InstanceType = "i3en.12xlarge"
	InstanceTypeI3en24xlarge InstanceType = "i3en.24xlarge"
	InstanceTypeI3enMetal    InstanceType = "i3en.metal"
	InstanceTypeHi14xlarge   InstanceType = "hi1.4xlarge"
	InstanceTypeHs18xlarge   InstanceType = "hs1.8xlarge"
	InstanceTypeC1Medium     InstanceType = "c1.medium"
	InstanceTypeC1Xlarge     InstanceType = "c1.xlarge"
	InstanceTypeC3Large      InstanceType = "c3.large"
	InstanceTypeC3Xlarge     InstanceType = "c3.xlarge"
	InstanceTypeC32xlarge    InstanceType = "c3.2xlarge"
	InstanceTypeC34xlarge    InstanceType = "c3.4xlarge"
	InstanceTypeC38xlarge    InstanceType = "c3.8xlarge"
	InstanceTypeC4Large      InstanceType = "c4.large"
	InstanceTypeC4Xlarge     InstanceType = "c4.xlarge"
	InstanceTypeC42xlarge    InstanceType = "c4.2xlarge"
	InstanceTypeC44xlarge    InstanceType = "c4.4xlarge"
	InstanceTypeC48xlarge    InstanceType = "c4.8xlarge"
	InstanceTypeC5Large      InstanceType = "c5.large"
	InstanceTypeC5Xlarge     InstanceType = "c5.xlarge"
	InstanceTypeC52xlarge    InstanceType = "c5.2xlarge"
	InstanceTypeC54xlarge    InstanceType = "c5.4xlarge"
	InstanceTypeC59xlarge    InstanceType = "c5.9xlarge"
	InstanceTypeC512xlarge   InstanceType = "c5.12xlarge"
	InstanceTypeC518xlarge   InstanceType = "c5.18xlarge"
	InstanceTypeC524xlarge   InstanceType = "c5.24xlarge"
	InstanceTypeC5Metal      InstanceType = "c5.metal"
	InstanceTypeC5aLarge     InstanceType = "c5a.large"
	InstanceTypeC5aXlarge    InstanceType = "c5a.xlarge"
	InstanceTypeC5a2xlarge   InstanceType = "c5a.2xlarge"
	InstanceTypeC5a4xlarge   InstanceType = "c5a.4xlarge"
	InstanceTypeC5a8xlarge   InstanceType = "c5a.8xlarge"
	InstanceTypeC5a12xlarge  InstanceType = "c5a.12xlarge"
	InstanceTypeC5a16xlarge  InstanceType = "c5a.16xlarge"
	InstanceTypeC5a24xlarge  InstanceType = "c5a.24xlarge"
	InstanceTypeC5dLarge     InstanceType = "c5d.large"
	InstanceTypeC5dXlarge    InstanceType = "c5d.xlarge"
	InstanceTypeC5d2xlarge   InstanceType = "c5d.2xlarge"
	InstanceTypeC5d4xlarge   InstanceType = "c5d.4xlarge"
	InstanceTypeC5d9xlarge   InstanceType = "c5d.9xlarge"
	InstanceTypeC5d12xlarge  InstanceType = "c5d.12xlarge"
	InstanceTypeC5d18xlarge  InstanceType = "c5d.18xlarge"
	InstanceTypeC5d24xlarge  InstanceType = "c5d.24xlarge"
	InstanceTypeC5dMetal     InstanceType = "c5d.metal"
	InstanceTypeC5nLarge     InstanceType = "c5n.large"
	InstanceTypeC5nXlarge    InstanceType = "c5n.xlarge"
	InstanceTypeC5n2xlarge   InstanceType = "c5n.2xlarge"
	InstanceTypeC5n4xlarge   InstanceType = "c5n.4xlarge"
	InstanceTypeC5n9xlarge   InstanceType = "c5n.9xlarge"
	InstanceTypeC5n18xlarge  InstanceType = "c5n.18xlarge"
	InstanceTypeC6gMetal     InstanceType = "c6g.metal"
	InstanceTypeC6gMedium    InstanceType = "c6g.medium"
	InstanceTypeC6gLarge     InstanceType = "c6g.large"
	InstanceTypeC6gXlarge    InstanceType = "c6g.xlarge"
	InstanceTypeC6g2xlarge   InstanceType = "c6g.2xlarge"
	InstanceTypeC6g4xlarge   InstanceType = "c6g.4xlarge"
	InstanceTypeC6g8xlarge   InstanceType = "c6g.8xlarge"
	InstanceTypeC6g12xlarge  InstanceType = "c6g.12xlarge"
	InstanceTypeC6g16xlarge  InstanceType = "c6g.16xlarge"
	InstanceTypeC6gdMetal    InstanceType = "c6gd.metal"
	InstanceTypeC6gdMedium   InstanceType = "c6gd.medium"
	InstanceTypeC6gdLarge    InstanceType = "c6gd.large"
	InstanceTypeC6gdXlarge   InstanceType = "c6gd.xlarge"
	InstanceTypeC6gd2xlarge  InstanceType = "c6gd.2xlarge"
	InstanceTypeC6gd4xlarge  InstanceType = "c6gd.4xlarge"
	InstanceTypeC6gd8xlarge  InstanceType = "c6gd.8xlarge"
	InstanceTypeC6gd12xlarge InstanceType = "c6gd.12xlarge"
	InstanceTypeC6gd16xlarge InstanceType = "c6gd.16xlarge"
	InstanceTypeCc14xlarge   InstanceType = "cc1.4xlarge"
	InstanceTypeCc28xlarge   InstanceType = "cc2.8xlarge"
	InstanceTypeG22xlarge    InstanceType = "g2.2xlarge"
	InstanceTypeG28xlarge    InstanceType = "g2.8xlarge"
	InstanceTypeG34xlarge    InstanceType = "g3.4xlarge"
	InstanceTypeG38xlarge    InstanceType = "g3.8xlarge"
	InstanceTypeG316xlarge   InstanceType = "g3.16xlarge"
	InstanceTypeG3sXlarge    InstanceType = "g3s.xlarge"
	InstanceTypeG4dnXlarge   InstanceType = "g4dn.xlarge"
	InstanceTypeG4dn2xlarge  InstanceType = "g4dn.2xlarge"
	InstanceTypeG4dn4xlarge  InstanceType = "g4dn.4xlarge"
	InstanceTypeG4dn8xlarge  InstanceType = "g4dn.8xlarge"
	InstanceTypeG4dn12xlarge InstanceType = "g4dn.12xlarge"
	InstanceTypeG4dn16xlarge InstanceType = "g4dn.16xlarge"
	InstanceTypeG4dnMetal    InstanceType = "g4dn.metal"
	InstanceTypeCg14xlarge   InstanceType = "cg1.4xlarge"
	InstanceTypeP2Xlarge     InstanceType = "p2.xlarge"
	InstanceTypeP28xlarge    InstanceType = "p2.8xlarge"
	InstanceTypeP216xlarge   InstanceType = "p2.16xlarge"
	InstanceTypeP32xlarge    InstanceType = "p3.2xlarge"
	InstanceTypeP38xlarge    InstanceType = "p3.8xlarge"
	InstanceTypeP316xlarge   InstanceType = "p3.16xlarge"
	InstanceTypeP3dn24xlarge InstanceType = "p3dn.24xlarge"
	InstanceTypeD2Xlarge     InstanceType = "d2.xlarge"
	InstanceTypeD22xlarge    InstanceType = "d2.2xlarge"
	InstanceTypeD24xlarge    InstanceType = "d2.4xlarge"
	InstanceTypeD28xlarge    InstanceType = "d2.8xlarge"
	InstanceTypeF12xlarge    InstanceType = "f1.2xlarge"
	InstanceTypeF14xlarge    InstanceType = "f1.4xlarge"
	InstanceTypeF116xlarge   InstanceType = "f1.16xlarge"
	InstanceTypeM5Large      InstanceType = "m5.large"
	InstanceTypeM5Xlarge     InstanceType = "m5.xlarge"
	InstanceTypeM52xlarge    InstanceType = "m5.2xlarge"
	InstanceTypeM54xlarge    InstanceType = "m5.4xlarge"
	InstanceTypeM58xlarge    InstanceType = "m5.8xlarge"
	InstanceTypeM512xlarge   InstanceType = "m5.12xlarge"
	InstanceTypeM516xlarge   InstanceType = "m5.16xlarge"
	InstanceTypeM524xlarge   InstanceType = "m5.24xlarge"
	InstanceTypeM5Metal      InstanceType = "m5.metal"
	InstanceTypeM5aLarge     InstanceType = "m5a.large"
	InstanceTypeM5aXlarge    InstanceType = "m5a.xlarge"
	InstanceTypeM5a2xlarge   InstanceType = "m5a.2xlarge"
	InstanceTypeM5a4xlarge   InstanceType = "m5a.4xlarge"
	InstanceTypeM5a8xlarge   InstanceType = "m5a.8xlarge"
	InstanceTypeM5a12xlarge  InstanceType = "m5a.12xlarge"
	InstanceTypeM5a16xlarge  InstanceType = "m5a.16xlarge"
	InstanceTypeM5a24xlarge  InstanceType = "m5a.24xlarge"
	InstanceTypeM5dLarge     InstanceType = "m5d.large"
	InstanceTypeM5dXlarge    InstanceType = "m5d.xlarge"
	InstanceTypeM5d2xlarge   InstanceType = "m5d.2xlarge"
	InstanceTypeM5d4xlarge   InstanceType = "m5d.4xlarge"
	InstanceTypeM5d8xlarge   InstanceType = "m5d.8xlarge"
	InstanceTypeM5d12xlarge  InstanceType = "m5d.12xlarge"
	InstanceTypeM5d16xlarge  InstanceType = "m5d.16xlarge"
	InstanceTypeM5d24xlarge  InstanceType = "m5d.24xlarge"
	InstanceTypeM5dMetal     InstanceType = "m5d.metal"
	InstanceTypeM5adLarge    InstanceType = "m5ad.large"
	InstanceTypeM5adXlarge   InstanceType = "m5ad.xlarge"
	InstanceTypeM5ad2xlarge  InstanceType = "m5ad.2xlarge"
	InstanceTypeM5ad4xlarge  InstanceType = "m5ad.4xlarge"
	InstanceTypeM5ad8xlarge  InstanceType = "m5ad.8xlarge"
	InstanceTypeM5ad12xlarge InstanceType = "m5ad.12xlarge"
	InstanceTypeM5ad16xlarge InstanceType = "m5ad.16xlarge"
	InstanceTypeM5ad24xlarge InstanceType = "m5ad.24xlarge"
	InstanceTypeH12xlarge    InstanceType = "h1.2xlarge"
	InstanceTypeH14xlarge    InstanceType = "h1.4xlarge"
	InstanceTypeH18xlarge    InstanceType = "h1.8xlarge"
	InstanceTypeH116xlarge   InstanceType = "h1.16xlarge"
	InstanceTypeZ1dLarge     InstanceType = "z1d.large"
	InstanceTypeZ1dXlarge    InstanceType = "z1d.xlarge"
	InstanceTypeZ1d2xlarge   InstanceType = "z1d.2xlarge"
	InstanceTypeZ1d3xlarge   InstanceType = "z1d.3xlarge"
	InstanceTypeZ1d6xlarge   InstanceType = "z1d.6xlarge"
	InstanceTypeZ1d12xlarge  InstanceType = "z1d.12xlarge"
	InstanceTypeZ1dMetal     InstanceType = "z1d.metal"
	InstanceTypeU6tb1Metal   InstanceType = "u-6tb1.metal"
	InstanceTypeU9tb1Metal   InstanceType = "u-9tb1.metal"
	InstanceTypeU12tb1Metal  InstanceType = "u-12tb1.metal"
	InstanceTypeU18tb1Metal  InstanceType = "u-18tb1.metal"
	InstanceTypeU24tb1Metal  InstanceType = "u-24tb1.metal"
	InstanceTypeA1Medium     InstanceType = "a1.medium"
	InstanceTypeA1Large      InstanceType = "a1.large"
	InstanceTypeA1Xlarge     InstanceType = "a1.xlarge"
	InstanceTypeA12xlarge    InstanceType = "a1.2xlarge"
	InstanceTypeA14xlarge    InstanceType = "a1.4xlarge"
	InstanceTypeA1Metal      InstanceType = "a1.metal"
	InstanceTypeM5dnLarge    InstanceType = "m5dn.large"
	InstanceTypeM5dnXlarge   InstanceType = "m5dn.xlarge"
	InstanceTypeM5dn2xlarge  InstanceType = "m5dn.2xlarge"
	InstanceTypeM5dn4xlarge  InstanceType = "m5dn.4xlarge"
	InstanceTypeM5dn8xlarge  InstanceType = "m5dn.8xlarge"
	InstanceTypeM5dn12xlarge InstanceType = "m5dn.12xlarge"
	InstanceTypeM5dn16xlarge InstanceType = "m5dn.16xlarge"
	InstanceTypeM5dn24xlarge InstanceType = "m5dn.24xlarge"
	InstanceTypeM5nLarge     InstanceType = "m5n.large"
	InstanceTypeM5nXlarge    InstanceType = "m5n.xlarge"
	InstanceTypeM5n2xlarge   InstanceType = "m5n.2xlarge"
	InstanceTypeM5n4xlarge   InstanceType = "m5n.4xlarge"
	InstanceTypeM5n8xlarge   InstanceType = "m5n.8xlarge"
	InstanceTypeM5n12xlarge  InstanceType = "m5n.12xlarge"
	InstanceTypeM5n16xlarge  InstanceType = "m5n.16xlarge"
	InstanceTypeM5n24xlarge  InstanceType = "m5n.24xlarge"
	InstanceTypeR5dnLarge    InstanceType = "r5dn.large"
	InstanceTypeR5dnXlarge   InstanceType = "r5dn.xlarge"
	InstanceTypeR5dn2xlarge  InstanceType = "r5dn.2xlarge"
	InstanceTypeR5dn4xlarge  InstanceType = "r5dn.4xlarge"
	InstanceTypeR5dn8xlarge  InstanceType = "r5dn.8xlarge"
	InstanceTypeR5dn12xlarge InstanceType = "r5dn.12xlarge"
	InstanceTypeR5dn16xlarge InstanceType = "r5dn.16xlarge"
	InstanceTypeR5dn24xlarge InstanceType = "r5dn.24xlarge"
	InstanceTypeR5nLarge     InstanceType = "r5n.large"
	InstanceTypeR5nXlarge    InstanceType = "r5n.xlarge"
	InstanceTypeR5n2xlarge   InstanceType = "r5n.2xlarge"
	InstanceTypeR5n4xlarge   InstanceType = "r5n.4xlarge"
	InstanceTypeR5n8xlarge   InstanceType = "r5n.8xlarge"
	InstanceTypeR5n12xlarge  InstanceType = "r5n.12xlarge"
	InstanceTypeR5n16xlarge  InstanceType = "r5n.16xlarge"
	InstanceTypeR5n24xlarge  InstanceType = "r5n.24xlarge"
	InstanceTypeInf1Xlarge   InstanceType = "inf1.xlarge"
	InstanceTypeInf12xlarge  InstanceType = "inf1.2xlarge"
	InstanceTypeInf16xlarge  InstanceType = "inf1.6xlarge"
	InstanceTypeInf124xlarge InstanceType = "inf1.24xlarge"
	InstanceTypeM6gMetal     InstanceType = "m6g.metal"
	InstanceTypeM6gMedium    InstanceType = "m6g.medium"
	InstanceTypeM6gLarge     InstanceType = "m6g.large"
	InstanceTypeM6gXlarge    InstanceType = "m6g.xlarge"
	InstanceTypeM6g2xlarge   InstanceType = "m6g.2xlarge"
	InstanceTypeM6g4xlarge   InstanceType = "m6g.4xlarge"
	InstanceTypeM6g8xlarge   InstanceType = "m6g.8xlarge"
	InstanceTypeM6g12xlarge  InstanceType = "m6g.12xlarge"
	InstanceTypeM6g16xlarge  InstanceType = "m6g.16xlarge"
	InstanceTypeM6gdMetal    InstanceType = "m6gd.metal"
	InstanceTypeM6gdMedium   InstanceType = "m6gd.medium"
	InstanceTypeM6gdLarge    InstanceType = "m6gd.large"
	InstanceTypeM6gdXlarge   InstanceType = "m6gd.xlarge"
	InstanceTypeM6gd2xlarge  InstanceType = "m6gd.2xlarge"
	InstanceTypeM6gd4xlarge  InstanceType = "m6gd.4xlarge"
	InstanceTypeM6gd8xlarge  InstanceType = "m6gd.8xlarge"
	InstanceTypeM6gd12xlarge InstanceType = "m6gd.12xlarge"
	InstanceTypeM6gd16xlarge InstanceType = "m6gd.16xlarge"
)

Enum values for InstanceType

type InstanceTypeHypervisor 

type InstanceTypeHypervisor string
const (
	InstanceTypeHypervisorNitro InstanceTypeHypervisor = "nitro"
	InstanceTypeHypervisorXen   InstanceTypeHypervisor = "xen"
)

Enum values for InstanceTypeHypervisor

type InstanceTypeInfo 

type InstanceTypeInfo struct {
	// Indicates the hypervisor used for the instance type.
	Hypervisor InstanceTypeHypervisor
	// Describes the Inference accelerator settings for the instance type.
	InferenceAcceleratorInfo *InferenceAcceleratorInfo
	// Describes the placement group settings for the instance type.
	PlacementGroupInfo *PlacementGroupInfo
	// Describes the network settings for the instance type.
	NetworkInfo *NetworkInfo
	// Describes the Amazon EBS settings for the instance type.
	EbsInfo *EbsInfo
	// Indicates whether On-Demand hibernation is supported.
	HibernationSupported *bool
	// Indicates whether the instance type is a current generation.
	CurrentGeneration *bool
	// Describes the disks for the instance type.
	InstanceStorageInfo *InstanceStorageInfo
	// Indicates whether the instance type is eligible for the free tier.
	FreeTierEligible *bool
	// Indicates whether auto recovery is supported.
	AutoRecoverySupported *bool
	// Indicates whether the instance is bare metal.
	BareMetal *bool
	// Describes the FPGA accelerator settings for the instance type.
	FpgaInfo *FpgaInfo
	// Describes the GPU accelerator settings for the instance type.
	GpuInfo *GpuInfo
	// Describes the vCPU configurations for the instance type.
	VCpuInfo *VCpuInfo
	// Indicates the supported root device types.
	SupportedRootDeviceTypes []RootDeviceType
	// The instance type. For more information, see Instance Types
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) in the
	// Amazon Elastic Compute Cloud User Guide.
	InstanceType InstanceType
	// The supported virtualization types.
	SupportedVirtualizationTypes []VirtualizationType
	// Describes the memory for the instance type.
	MemoryInfo *MemoryInfo
	// Indicates whether the instance type is offered for spot or On-Demand.
	SupportedUsageClasses []UsageClassType
	// Indicates whether Dedicated Hosts are supported on the instance type.
	DedicatedHostsSupported *bool
	// Describes the processor.
	ProcessorInfo *ProcessorInfo
	// Indicates whether the instance type is a burstable performance instance type.
	BurstablePerformanceSupported *bool
	// Indicates whether instance storage is supported.
	InstanceStorageSupported *bool
}

Describes the instance type.

type InstanceTypeOffering 

type InstanceTypeOffering struct {
	// The instance type. For more information, see Instance Types
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) in the
	// Amazon Elastic Compute Cloud User Guide.
	InstanceType InstanceType
	// The location type.
	LocationType LocationType
	// The identifier for the location. This depends on the location type. For example,
	// if the location type is region, the location is the Region code (for example,
	// us-east-2.)
	Location *string
}

The instance types offered.

type InstanceUsage 

type InstanceUsage struct {
	// The number of instances the AWS account currently has in the Capacity
	// Reservation.
	UsedInstanceCount *int32
	// The ID of the AWS account that is making use of the Capacity Reservation.
	AccountId *string
}

Information about the Capacity Reservation usage.

type InterfacePermissionType 

type InterfacePermissionType string
const (
	InterfacePermissionTypeInstanceAttach InterfacePermissionType = "INSTANCE-ATTACH"
	InterfacePermissionTypeEipAssociate   InterfacePermissionType = "EIP-ASSOCIATE"
)

Enum values for InterfacePermissionType

type InternetGateway 

type InternetGateway struct {
	// The ID of the internet gateway.
	InternetGatewayId *string
	// Any tags assigned to the internet gateway.
	Tags []*Tag
	// The ID of the AWS account that owns the internet gateway.
	OwnerId *string
	// Any VPCs attached to the internet gateway.
	Attachments []*InternetGatewayAttachment
}

Describes an internet gateway.

type InternetGatewayAttachment 

type InternetGatewayAttachment struct {
	// The ID of the VPC.
	VpcId *string
	// The current state of the attachment. For an internet gateway, the state is
	// available when attached to a VPC; otherwise, this value is not returned.
	State AttachmentStatus
}

Describes the attachment of a VPC to an internet gateway or an egress-only internet gateway.

type IpPermission 

type IpPermission struct {
	// The IPv4 ranges.
	IpRanges []*IpRange
	// [VPC only] The IPv6 ranges.
	Ipv6Ranges []*Ipv6Range
	// The end of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 code. A
	// value of -1 indicates all ICMP/ICMPv6 codes. If you specify all ICMP/ICMPv6
	// types, you must specify all codes.
	ToPort *int32
	// The start of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 type
	// number. A value of -1 indicates all ICMP/ICMPv6 types. If you specify all
	// ICMP/ICMPv6 types, you must specify all codes.
	FromPort *int32
	// The IP protocol name (tcp, udp, icmp, icmpv6) or number (see Protocol Numbers
	// (http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml)). [VPC
	// only] Use -1 to specify all protocols. When authorizing security group rules,
	// specifying -1 or a protocol number other than tcp, udp, icmp, or icmpv6 allows
	// traffic on all ports, regardless of any port range you specify. For tcp, udp,
	// and icmp, you must specify a port range. For icmpv6, the port range is optional;
	// if you omit the port range, traffic for all types and codes is allowed.
	IpProtocol *string
	// [VPC only] The prefix list IDs.
	PrefixListIds []*PrefixListId
	// The security group and AWS account ID pairs.
	UserIdGroupPairs []*UserIdGroupPair
}

Describes a set of permissions for a security group rule.

type IpRange 

type IpRange struct {
	// The IPv4 CIDR range. You can either specify a CIDR range or a source security
	// group, not both. To specify a single IPv4 address, use the /32 prefix length.
	CidrIp *string
	// A description for the security group rule that references this IPv4 address
	// range. Constraints: Up to 255 characters in length. Allowed characters are a-z,
	// A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*
	Description *string
}

Describes an IPv4 range.

type Ipv6CidrAssociation 

type Ipv6CidrAssociation struct {
	// The resource that's associated with the IPv6 CIDR block.
	AssociatedResource *string
	// The IPv6 CIDR block.
	Ipv6Cidr *string
}

Describes an IPv6 CIDR block association.

type Ipv6CidrBlock 

type Ipv6CidrBlock struct {
	// The IPv6 CIDR block.
	Ipv6CidrBlock *string
}

Describes an IPv6 CIDR block.

type Ipv6Pool 

type Ipv6Pool struct {
	// Any tags for the address pool.
	Tags []*Tag
	// The ID of the address pool.
	PoolId *string
	// The description for the address pool.
	Description *string
	// The CIDR blocks for the address pool.
	PoolCidrBlocks []*PoolCidrBlock
}

Describes an IPv6 address pool.

type Ipv6Range 

type Ipv6Range struct {
	// The IPv6 CIDR range. You can either specify a CIDR range or a source security
	// group, not both. To specify a single IPv6 address, use the /128 prefix length.
	CidrIpv6 *string
	// A description for the security group rule that references this IPv6 address
	// range. Constraints: Up to 255 characters in length. Allowed characters are a-z,
	// A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*
	Description *string
}

[EC2-VPC only] Describes an IPv6 range.

type Ipv6SupportValue 

type Ipv6SupportValue string
const (
	Ipv6SupportValueEnable  Ipv6SupportValue = "enable"
	Ipv6SupportValueDisable Ipv6SupportValue = "disable"
)

Enum values for Ipv6SupportValue

type KeyPairInfo 

type KeyPairInfo struct {
	// Any tags applied to the key pair.
	Tags []*Tag
	// If you used CreateKeyPair () to create the key pair, this is the SHA-1 digest of
	// the DER encoded private key. If you used ImportKeyPair () to provide AWS the
	// public key, this is the MD5 public key fingerprint as specified in section 4 of
	// RFC4716.
	KeyFingerprint *string
	// The ID of the key pair.
	KeyPairId *string
	// The name of the key pair.
	KeyName *string
}

Describes a key pair.

type LastError 

type LastError struct {
	// The error code for the VPC endpoint error.
	Code *string
	// The error message for the VPC endpoint error.
	Message *string
}

The last error that occurred for a VPC endpoint.

type LaunchPermission 

type LaunchPermission struct {
	// The AWS account ID.
	UserId *string
	// The name of the group.
	Group PermissionGroup
}

Describes a launch permission.

type LaunchPermissionModifications 

type LaunchPermissionModifications struct {
	// The AWS account ID to remove from the list of launch permissions for the AMI.
	Remove []*LaunchPermission
	// The AWS account ID to add to the list of launch permissions for the AMI.
	Add []*LaunchPermission
}

Describes a launch permission modification.

type LaunchSpecification 

type LaunchSpecification struct {
	// One or more block device mapping entries.
	BlockDeviceMappings []*BlockDeviceMapping
	// The ID of the subnet in which to launch the instance.
	SubnetId *string
	// The ID of the kernel.
	KernelId *string
	// The Base64-encoded user data for the instance.
	UserData *string
	// Deprecated.
	AddressingType *string
	// One or more security groups. When requesting instances in a VPC, you must
	// specify the IDs of the security groups. When requesting instances in
	// EC2-Classic, you can specify the names or the IDs of the security groups.
	SecurityGroups []*GroupIdentifier
	// The ID of the AMI.
	ImageId *string
	// Indicates whether the instance is optimized for EBS I/O. This optimization
	// provides dedicated throughput to Amazon EBS and an optimized configuration stack
	// to provide optimal EBS I/O performance. This optimization isn't available with
	// all instance types. Additional usage charges apply when using an EBS Optimized
	// instance. Default: false
	EbsOptimized *bool
	// The ID of the RAM disk.
	RamdiskId *string
	// The instance type.
	InstanceType InstanceType
	// The placement information for the instance.
	Placement *SpotPlacement
	// The name of the key pair.
	KeyName *string
	// One or more network interfaces. If you specify a network interface, you must
	// specify subnet IDs and security group IDs using the network interface.
	NetworkInterfaces []*InstanceNetworkInterfaceSpecification
	// The IAM instance profile.
	IamInstanceProfile *IamInstanceProfileSpecification
	// Describes the monitoring of an instance.
	Monitoring *RunInstancesMonitoringEnabled
}

Describes the launch specification for an instance.

type LaunchTemplate 

type LaunchTemplate struct {
	// The version number of the default version of the launch template.
	DefaultVersionNumber *int64
	// The version number of the latest version of the launch template.
	LatestVersionNumber *int64
	// The time launch template was created.
	CreateTime *time.Time
	// The ID of the launch template.
	LaunchTemplateId *string
	// The name of the launch template.
	LaunchTemplateName *string
	// The tags for the launch template.
	Tags []*Tag
	// The principal that created the launch template.
	CreatedBy *string
}

Describes a launch template.

type LaunchTemplateAndOverridesResponse 

type LaunchTemplateAndOverridesResponse 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 LaunchTemplateBlockDeviceMapping 

type LaunchTemplateBlockDeviceMapping struct {
	// Information about the block device for an EBS volume.
	Ebs *LaunchTemplateEbsBlockDevice
	// The virtual device name (ephemeralN).
	VirtualName *string
	// The device name.
	DeviceName *string
	// Suppresses the specified device included in the block device mapping of the AMI.
	NoDevice *string
}

Describes a block device mapping.

type LaunchTemplateBlockDeviceMappingRequest 

type LaunchTemplateBlockDeviceMappingRequest 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 *LaunchTemplateEbsBlockDeviceRequest
	// Suppresses the specified device included in the block device mapping of the AMI.
	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.
	VirtualName *string
}

Describes a block device mapping.

type LaunchTemplateCapacityReservationSpecificationRequest 

type LaunchTemplateCapacityReservationSpecificationRequest struct {
	// Information about the target Capacity Reservation or Capacity Reservation group.
	CapacityReservationTarget *CapacityReservationTarget
	// 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 in On-Demand capacity.
	CapacityReservationPreference CapacityReservationPreference
}

Describes an instance's Capacity Reservation targeting option. You can specify only one option at a time. Use the CapacityReservationPreference parameter to configure the instance to run in On-Demand capacity 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 LaunchTemplateCapacityReservationSpecificationResponse 

type LaunchTemplateCapacityReservationSpecificationResponse struct {
	// Information about the target Capacity Reservation or Capacity Reservation group.
	CapacityReservationTarget *CapacityReservationTargetResponse
	// 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 in On-Demand capacity.
	CapacityReservationPreference CapacityReservationPreference
}

Information about the Capacity Reservation targeting option.

type LaunchTemplateConfig 

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

Describes a launch template and overrides.

type LaunchTemplateCpuOptions 

type LaunchTemplateCpuOptions 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 LaunchTemplateCpuOptionsRequest 

type LaunchTemplateCpuOptionsRequest 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 LaunchTemplateEbsBlockDevice 

type LaunchTemplateEbsBlockDevice struct {
	// The volume type.
	VolumeType VolumeType
	// Indicates whether the EBS volume is encrypted.
	Encrypted *bool
	// The number of I/O operations per second (IOPS) that the volume supports.
	Iops *int32
	// Indicates whether the EBS volume is deleted on instance termination.
	DeleteOnTermination *bool
	// The ARN of the AWS Key Management Service (AWS KMS) CMK used for encryption.
	KmsKeyId *string
	// The size of the volume, in GiB.
	VolumeSize *int32
	// The ID of the snapshot.
	SnapshotId *string
}

Describes a block device for an EBS volume.

type LaunchTemplateEbsBlockDeviceRequest 

type LaunchTemplateEbsBlockDeviceRequest struct {
	// The ARN of the symmetric AWS Key Management Service (AWS KMS) CMK used for
	// encryption.
	KmsKeyId *string
	// The size of the volume, in GiB. Default: If you're creating the volume from a
	// snapshot and don't specify a volume size, the default is the snapshot size.
	VolumeSize *int32
	// Indicates whether the EBS volume is encrypted. Encrypted volumes can only be
	// attached to instances that support Amazon EBS encryption. If you are creating a
	// volume from a snapshot, you can't specify an encryption value.
	Encrypted *bool
	// Indicates whether the EBS volume is deleted on instance termination.
	DeleteOnTermination *bool
	// The ID of the snapshot.
	SnapshotId *string
	// The volume type.
	VolumeType VolumeType
	// The number of I/O operations per second (IOPS) that the volume supports. For
	// io1, this represents the number of IOPS that are provisioned for the volume. For
	// gp2, this represents the baseline performance of the volume and the rate at
	// which the volume accumulates I/O credits for bursting. For more information
	// about General Purpose SSD baseline performance, I/O credits, and bursting, see
	// Amazon EBS Volume Types
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html) in the
	// Amazon Elastic Compute Cloud User Guide. Condition: This parameter is required
	// for requests to create io1 volumes; it is not used in requests to create gp2,
	// st1, sc1, or standard volumes.
	Iops *int32
}

The parameters for a block device for an EBS volume.

type LaunchTemplateElasticInferenceAccelerator 

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

Describes an elastic inference accelerator.

type LaunchTemplateElasticInferenceAcceleratorResponse 

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

Describes an elastic inference accelerator.

type LaunchTemplateErrorCode 

type LaunchTemplateErrorCode string
const (
	LaunchTemplateErrorCodeLaunch_template_id_does_not_exist      LaunchTemplateErrorCode = "launchTemplateIdDoesNotExist"
	LaunchTemplateErrorCodeLaunch_template_id_malformed           LaunchTemplateErrorCode = "launchTemplateIdMalformed"
	LaunchTemplateErrorCodeLaunch_template_name_does_not_exist    LaunchTemplateErrorCode = "launchTemplateNameDoesNotExist"
	LaunchTemplateErrorCodeLaunch_template_name_malformed         LaunchTemplateErrorCode = "launchTemplateNameMalformed"
	LaunchTemplateErrorCodeLaunch_template_version_does_not_exist LaunchTemplateErrorCode = "launchTemplateVersionDoesNotExist"
	LaunchTemplateErrorCodeUnexpected_error                       LaunchTemplateErrorCode = "unexpectedError"
)

Enum values for LaunchTemplateErrorCode

type LaunchTemplateHibernationOptions 

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

Indicates whether an instance is configured for hibernation.

type LaunchTemplateHibernationOptionsRequest 

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

Indicates whether the 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).

type LaunchTemplateHttpTokensState 

type LaunchTemplateHttpTokensState string
const (
	LaunchTemplateHttpTokensStateOptional LaunchTemplateHttpTokensState = "optional"
	LaunchTemplateHttpTokensStateRequired LaunchTemplateHttpTokensState = "required"
)

Enum values for LaunchTemplateHttpTokensState

type LaunchTemplateIamInstanceProfileSpecification 

type LaunchTemplateIamInstanceProfileSpecification struct {
	// The name of the instance profile.
	Name *string
	// The Amazon Resource Name (ARN) of the instance profile.
	Arn *string
}

Describes an IAM instance profile.

type LaunchTemplateIamInstanceProfileSpecificationRequest 

type LaunchTemplateIamInstanceProfileSpecificationRequest struct {
	// The name of the instance profile.
	Name *string
	// The Amazon Resource Name (ARN) of the instance profile.
	Arn *string
}

An IAM instance profile.

type LaunchTemplateInstanceMarketOptions 

type LaunchTemplateInstanceMarketOptions struct {
	// The options for Spot Instances.
	SpotOptions *LaunchTemplateSpotMarketOptions
	// The market type.
	MarketType MarketType
}

The market (purchasing) option for the instances.

type LaunchTemplateInstanceMarketOptionsRequest 

type LaunchTemplateInstanceMarketOptionsRequest struct {
	// The options for Spot Instances.
	SpotOptions *LaunchTemplateSpotMarketOptionsRequest
	// The market type.
	MarketType MarketType
}

The market (purchasing) option for the instances.

type LaunchTemplateInstanceMetadataEndpointState 

type LaunchTemplateInstanceMetadataEndpointState string
const (
	LaunchTemplateInstanceMetadataEndpointStateDisabled LaunchTemplateInstanceMetadataEndpointState = "disabled"
	LaunchTemplateInstanceMetadataEndpointStateEnabled  LaunchTemplateInstanceMetadataEndpointState = "enabled"
)

Enum values for LaunchTemplateInstanceMetadataEndpointState

type LaunchTemplateInstanceMetadataOptions 

type LaunchTemplateInstanceMetadataOptions struct {
	// The state of token usage for your instance metadata requests. If the parameter
	// is not specified in the request, the default state is optional. If the state is
	// optional, you can choose to retrieve instance metadata with or without a signed
	// token header on your request. If you retrieve the IAM role credentials without a
	// token, the version 1.0 role credentials are returned. If you retrieve the IAM
	// role credentials using a valid signed token, the version 2.0 role credentials
	// are returned. If the state is required, you must send a signed token header with
	// any instance metadata retrieval requests. In this state, retrieving the IAM role
	// credentials always returns the version 2.0 credentials; the version 1.0
	// credentials are not available.
	HttpTokens LaunchTemplateHttpTokensState
	// The state of the metadata option changes. pending - The metadata options are
	// being updated and the instance is not ready to process metadata traffic with the
	// new selection. applied - The metadata options have been successfully applied on
	// the instance.
	State LaunchTemplateInstanceMetadataOptionsState
	// The desired HTTP PUT response hop limit for instance metadata requests. The
	// larger the number, the further instance metadata requests can travel. Default: 1
	// Possible values: Integers from 1 to 64
	HttpPutResponseHopLimit *int32
	// This parameter enables or disables the HTTP metadata endpoint on your instances.
	// If the parameter is not specified, the default state is enabled. If you specify
	// a value of disabled, you will not be able to access your instance metadata.
	HttpEndpoint LaunchTemplateInstanceMetadataEndpointState
}

The metadata options for the instance. For more information, see Instance Metadata and User Data (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) in the Amazon Elastic Compute Cloud User Guide.

type LaunchTemplateInstanceMetadataOptionsRequest 

type LaunchTemplateInstanceMetadataOptionsRequest struct {
	// This parameter enables or disables the HTTP metadata endpoint on your instances.
	// If the parameter is not specified, the default state is enabled. If you specify
	// a value of disabled, you will not be able to access your instance metadata.
	HttpEndpoint LaunchTemplateInstanceMetadataEndpointState
	// The desired HTTP PUT response hop limit for instance metadata requests. The
	// larger the number, the further instance metadata requests can travel. Default: 1
	// Possible values: Integers from 1 to 64
	HttpPutResponseHopLimit *int32
	// The state of token usage for your instance metadata requests. If the parameter
	// is not specified in the request, the default state is optional. If the state is
	// optional, you can choose to retrieve instance metadata with or without a signed
	// token header on your request. If you retrieve the IAM role credentials without a
	// token, the version 1.0 role credentials are returned. If you retrieve the IAM
	// role credentials using a valid signed token, the version 2.0 role credentials
	// are returned. If the state is required, you must send a signed token header with
	// any instance metadata retrieval requests. In this state, retrieving the IAM role
	// credentials always returns the version 2.0 credentials; the version 1.0
	// credentials are not available.
	HttpTokens LaunchTemplateHttpTokensState
}

The metadata options for the instance. For more information, see Instance Metadata and User Data (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) in the Amazon Elastic Compute Cloud User Guide.

type LaunchTemplateInstanceMetadataOptionsState 

type LaunchTemplateInstanceMetadataOptionsState string
const (
	LaunchTemplateInstanceMetadataOptionsStatePending LaunchTemplateInstanceMetadataOptionsState = "pending"
	LaunchTemplateInstanceMetadataOptionsStateApplied LaunchTemplateInstanceMetadataOptionsState = "applied"
)

Enum values for LaunchTemplateInstanceMetadataOptionsState

type LaunchTemplateInstanceNetworkInterfaceSpecification 

type LaunchTemplateInstanceNetworkInterfaceSpecification struct {
	// Indicates whether to associate a public IPv4 address with eth0 for a new network
	// interface.
	AssociatePublicIpAddress *bool
	// A description for the network interface.
	Description *string
	// The number of IPv6 addresses for the network interface.
	Ipv6AddressCount *int32
	// The ID of the subnet for the network interface.
	SubnetId *string
	// One or more private IPv4 addresses.
	PrivateIpAddresses []*PrivateIpAddressSpecification
	// The primary private IPv4 address of the network interface.
	PrivateIpAddress *string
	// The device index for the network interface attachment.
	DeviceIndex *int32
	// The ID of the network interface.
	NetworkInterfaceId *string
	// Indicates whether the network interface is deleted when the instance is
	// terminated.
	DeleteOnTermination *bool
	// The IPv6 addresses for the network interface.
	Ipv6Addresses []*InstanceIpv6Address
	// The IDs of one or more security groups.
	Groups []*string
	// The type of network interface.
	InterfaceType *string
	// The number of secondary private IPv4 addresses for the network interface.
	SecondaryPrivateIpAddressCount *int32
}

Describes a network interface.

type LaunchTemplateInstanceNetworkInterfaceSpecificationRequest 

type LaunchTemplateInstanceNetworkInterfaceSpecificationRequest struct {
	// The number of IPv6 addresses to assign to a network interface. Amazon EC2
	// automatically selects the IPv6 addresses from the subnet range. You can't use
	// this option if specifying specific IPv6 addresses.
	Ipv6AddressCount *int32
	// One or more specific IPv6 addresses from the IPv6 CIDR block range of your
	// subnet. You can't use this option if you're specifying a number of IPv6
	// addresses.
	Ipv6Addresses []*InstanceIpv6AddressRequest
	// The ID of the subnet for the network interface.
	SubnetId *string
	// Indicates whether the network interface is deleted when the instance is
	// terminated.
	DeleteOnTermination *bool
	// The ID of the network interface.
	NetworkInterfaceId *string
	// Associates a public IPv4 address with eth0 for a new network interface.
	AssociatePublicIpAddress *bool
	// The number of secondary private IPv4 addresses to assign to a network interface.
	SecondaryPrivateIpAddressCount *int32
	// One or more private IPv4 addresses.
	PrivateIpAddresses []*PrivateIpAddressSpecification
	// A description for the network interface.
	Description *string
	// The IDs of one or more security groups.
	Groups []*string
	// The device index for the network interface attachment.
	DeviceIndex *int32
	// The type of network interface. To create an Elastic Fabric Adapter (EFA),
	// specify efa. For more information, see Elastic Fabric Adapter
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) in the Amazon
	// Elastic Compute Cloud User Guide. If you are not creating an EFA, specify
	// interface or omit this parameter. Valid values: interface | efa
	InterfaceType *string
	// The primary private IPv4 address of the network interface.
	PrivateIpAddress *string
}

The parameters for a network interface.

type LaunchTemplateLicenseConfiguration 

type LaunchTemplateLicenseConfiguration struct {
	// The Amazon Resource Name (ARN) of the license configuration.
	LicenseConfigurationArn *string
}

Describes a license configuration.

type LaunchTemplateLicenseConfigurationRequest 

type LaunchTemplateLicenseConfigurationRequest struct {
	// The Amazon Resource Name (ARN) of the license configuration.
	LicenseConfigurationArn *string
}

Describes a license configuration.

type LaunchTemplateOverrides 

type LaunchTemplateOverrides struct {
	// The priority for the launch template override. If OnDemandAllocationStrategy is
	// set to prioritized, Spot 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 instance type.
	InstanceType InstanceType
	// The maximum price per unit hour that you are willing to pay for a Spot Instance.
	SpotPrice *string
	// The number of units provided by the specified instance type.
	WeightedCapacity *float64
	// The ID of the subnet in which to launch the instances.
	SubnetId *string
	// The Availability Zone in which to launch the instances.
	AvailabilityZone *string
}

Describes overrides for a launch template.

type LaunchTemplatePlacement 

type LaunchTemplatePlacement struct {
	// The ID of the Dedicated Host for the instance.
	HostId *string
	// Reserved for future use.
	SpreadDomain *string
	// The Availability Zone of the instance.
	AvailabilityZone *string
	// The name of the placement group for the instance.
	GroupName *string
	// The affinity setting for the instance on the Dedicated Host.
	Affinity *string
	// The ARN of the host resource group in which to launch the instances.
	HostResourceGroupArn *string
	// The number of the partition the instance should launch in. Valid only if the
	// placement group strategy is set to partition.
	PartitionNumber *int32
	// The tenancy of the instance (if the instance is running in a VPC). An instance
	// with a tenancy of dedicated runs on single-tenant hardware.
	Tenancy Tenancy
}

Describes the placement of an instance.

type LaunchTemplatePlacementRequest 

type LaunchTemplatePlacementRequest struct {
	// The number of the partition the instance should launch in. Valid only if the
	// placement group strategy is set to partition.
	PartitionNumber *int32
	// The tenancy of the instance (if the instance is running in a VPC). An instance
	// with a tenancy of dedicated runs on single-tenant hardware.
	Tenancy Tenancy
	// Reserved for future use.
	SpreadDomain *string
	// The ARN of the host resource group in which to launch the instances. If you
	// specify a host resource group ARN, omit the Tenancy parameter or set it to host.
	HostResourceGroupArn *string
	// The ID of the Dedicated Host for the instance.
	HostId *string
	// The affinity setting for an instance on a Dedicated Host.
	Affinity *string
	// The Availability Zone for the instance.
	AvailabilityZone *string
	// The name of the placement group for the instance.
	GroupName *string
}

Describes the placement of an instance.

type LaunchTemplateSpecification 

type LaunchTemplateSpecification struct {
	// The version number of the launch template. Default: The default version for the
	// launch template.
	Version *string
	// The name of the launch template.
	LaunchTemplateName *string
	// The ID of the launch template.
	LaunchTemplateId *string
}

The launch template to use. You must specify either the launch template ID or launch template name in the request, but not both.

type LaunchTemplateSpotMarketOptions 

type LaunchTemplateSpotMarketOptions struct {
	// The maximum hourly price you're willing to pay for the Spot Instances.
	MaxPrice *string
	// The behavior when a Spot Instance is interrupted.
	InstanceInterruptionBehavior InstanceInterruptionBehavior
	// The required duration for the Spot Instances (also known as Spot blocks), in
	// minutes. This value must be a multiple of 60 (60, 120, 180, 240, 300, or 360).
	BlockDurationMinutes *int32
	// The end date of the request. For a one-time request, the request remains active
	// until all instances launch, the request is canceled, or this date is reached. If
	// the request is persistent, it remains active until it is canceled or this date
	// and time is reached.
	ValidUntil *time.Time
	// The Spot Instance request type.
	SpotInstanceType SpotInstanceType
}

The options for Spot Instances.

type LaunchTemplateSpotMarketOptionsRequest 

type LaunchTemplateSpotMarketOptionsRequest struct {
	// The Spot Instance request type.
	SpotInstanceType SpotInstanceType
	// The behavior when a Spot Instance is interrupted. The default is terminate.
	InstanceInterruptionBehavior InstanceInterruptionBehavior
	// The end date of the request. For a one-time request, the request remains active
	// until all instances launch, the request is canceled, or this date is reached. If
	// the request is persistent, it remains active until it is canceled or this date
	// and time is reached. The default end date is 7 days from the current date.
	ValidUntil *time.Time
	// The required duration for the Spot Instances (also known as Spot blocks), in
	// minutes. This value must be a multiple of 60 (60, 120, 180, 240, 300, or 360).
	BlockDurationMinutes *int32
	// The maximum hourly price you're willing to pay for the Spot Instances.
	MaxPrice *string
}

The options for Spot Instances.

type LaunchTemplateTagSpecification 

type LaunchTemplateTagSpecification struct {
	// The type of resource.
	ResourceType ResourceType
	// The tags for the resource.
	Tags []*Tag
}

The tag specification for the launch template.

type LaunchTemplateTagSpecificationRequest 

type LaunchTemplateTagSpecificationRequest struct {
	// The type of resource to tag. Currently, the resource types that support tagging
	// on creation are instance and volume. To tag a resource after it has been
	// created, see CreateTags
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTags.html).
	ResourceType ResourceType
	// The tags to apply to the resource.
	Tags []*Tag
}

The tags specification for the launch template.

type LaunchTemplateVersion 

type LaunchTemplateVersion struct {
	// The description for the version.
	VersionDescription *string
	// The version number.
	VersionNumber *int64
	// Indicates whether the version is the default version.
	DefaultVersion *bool
	// The ID of the launch template.
	LaunchTemplateId *string
	// The time the version was created.
	CreateTime *time.Time
	// The principal that created the version.
	CreatedBy *string
	// Information about the launch template.
	LaunchTemplateData *ResponseLaunchTemplateData
	// The name of the launch template.
	LaunchTemplateName *string
}

Describes a launch template version.

type LaunchTemplatesMonitoring 

type LaunchTemplatesMonitoring struct {
	// Indicates whether detailed monitoring is enabled. Otherwise, basic monitoring is
	// enabled.
	Enabled *bool
}

Describes the monitoring for the instance.

type LaunchTemplatesMonitoringRequest 

type LaunchTemplatesMonitoringRequest struct {
	// Specify true to enable detailed monitoring. Otherwise, basic monitoring is
	// enabled.
	Enabled *bool
}

Describes the monitoring for the instance.

type LicenseConfiguration 

type LicenseConfiguration struct {
	// The Amazon Resource Name (ARN) of the license configuration.
	LicenseConfigurationArn *string
}

Describes a license configuration.

type LicenseConfigurationRequest 

type LicenseConfigurationRequest struct {
	// The Amazon Resource Name (ARN) of the license configuration.
	LicenseConfigurationArn *string
}

Describes a license configuration.

type ListingState 

type ListingState string
const (
	ListingStateAvailable ListingState = "available"
	ListingStateSold      ListingState = "sold"
	ListingStateCancelled ListingState = "cancelled"
	ListingStatePending   ListingState = "pending"
)

Enum values for ListingState

type ListingStatus 

type ListingStatus string
const (
	ListingStatusActive    ListingStatus = "active"
	ListingStatusPending   ListingStatus = "pending"
	ListingStatusCancelled ListingStatus = "cancelled"
	ListingStatusClosed    ListingStatus = "closed"
)

Enum values for ListingStatus

type LoadBalancersConfig 

type LoadBalancersConfig struct {
	// The target groups.
	TargetGroupsConfig *TargetGroupsConfig
	// The Classic Load Balancers.
	ClassicLoadBalancersConfig *ClassicLoadBalancersConfig
}

Describes the Classic Load Balancers and target groups to attach to a Spot Fleet request.

type LoadPermission 

type LoadPermission struct {
	// The AWS account ID.
	UserId *string
	// The name of the group.
	Group PermissionGroup
}

Describes a load permission.

type LoadPermissionModifications 

type LoadPermissionModifications struct {
	// The load permissions to remove.
	Remove []*LoadPermissionRequest
	// The load permissions to add.
	Add []*LoadPermissionRequest
}

Describes modifications to the load permissions of an Amazon FPGA image (AFI).

type LoadPermissionRequest 

type LoadPermissionRequest struct {
	// The AWS account ID.
	UserId *string
	// The name of the group.
	Group PermissionGroup
}

Describes a load permission.

type LocalGateway 

type LocalGateway struct {
	// The state of the local gateway.
	State *string
	// The Amazon Resource Name (ARN) of the Outpost.
	OutpostArn *string
	// The tags assigned to the local gateway.
	Tags []*Tag
	// The ID of the AWS account ID that owns the local gateway.
	OwnerId *string
	// The ID of the local gateway.
	LocalGatewayId *string
}

Describes a local gateway.

type LocalGatewayRoute 

type LocalGatewayRoute struct {
	// The state of the route.
	State LocalGatewayRouteState
	// The ID of the local gateway route table.
	LocalGatewayRouteTableId *string
	// The route type.
	Type LocalGatewayRouteType
	// The CIDR block used for destination matches.
	DestinationCidrBlock *string
	// The ID of the virtual interface group.
	LocalGatewayVirtualInterfaceGroupId *string
}

Describes a route for a local gateway route table.

type LocalGatewayRouteState 

type LocalGatewayRouteState string
const (
	LocalGatewayRouteStatePending   LocalGatewayRouteState = "pending"
	LocalGatewayRouteStateActive    LocalGatewayRouteState = "active"
	LocalGatewayRouteStateBlackhole LocalGatewayRouteState = "blackhole"
	LocalGatewayRouteStateDeleting  LocalGatewayRouteState = "deleting"
	LocalGatewayRouteStateDeleted   LocalGatewayRouteState = "deleted"
)

Enum values for LocalGatewayRouteState

type LocalGatewayRouteTable 

type LocalGatewayRouteTable struct {
	// The tags assigned to the local gateway route table.
	Tags []*Tag
	// The ID of the local gateway.
	LocalGatewayId *string
	// The state of the local gateway route table.
	State *string
	// The ID of the local gateway route table.
	LocalGatewayRouteTableId *string
	// The Amazon Resource Name (ARN) of the Outpost.
	OutpostArn *string
}

Describes a local gateway route table.

type LocalGatewayRouteTableVirtualInterfaceGroupAssociation 

type LocalGatewayRouteTableVirtualInterfaceGroupAssociation struct {
	// The ID of the association.
	LocalGatewayRouteTableVirtualInterfaceGroupAssociationId *string
	// The ID of the local gateway.
	LocalGatewayId *string
	// The tags assigned to the association.
	Tags []*Tag
	// The state of the association.
	State *string
	// The ID of the local gateway route table.
	LocalGatewayRouteTableId *string
	// The ID of the virtual interface group.
	LocalGatewayVirtualInterfaceGroupId *string
}

Describes an association between a local gateway route table and a virtual interface group.

type LocalGatewayRouteTableVpcAssociation 

type LocalGatewayRouteTableVpcAssociation struct {
	// The ID of the association.
	LocalGatewayRouteTableVpcAssociationId *string
	// The ID of the local gateway route table.
	LocalGatewayRouteTableId *string
	// The state of the association.
	State *string
	// The ID of the VPC.
	VpcId *string
	// The ID of the local gateway.
	LocalGatewayId *string
	// The tags assigned to the association.
	Tags []*Tag
}

Describes an association between a local gateway route table and a VPC.

type LocalGatewayRouteType 

type LocalGatewayRouteType string
const (
	LocalGatewayRouteTypeStatic     LocalGatewayRouteType = "static"
	LocalGatewayRouteTypePropagated LocalGatewayRouteType = "propagated"
)

Enum values for LocalGatewayRouteType

type LocalGatewayVirtualInterface 

type LocalGatewayVirtualInterface struct {
	// The ID of the VLAN.
	Vlan *int32
	// The Border Gateway Protocol (BGP) Autonomous System Number (ASN) of the local
	// gateway.
	LocalBgpAsn *int32
	// The ID of the local gateway.
	LocalGatewayId *string
	// The tags assigned to the virtual interface.
	Tags []*Tag
	// The peer BGP ASN.
	PeerBgpAsn *int32
	// The peer address.
	PeerAddress *string
	// The local address.
	LocalAddress *string
	// The ID of the virtual interface.
	LocalGatewayVirtualInterfaceId *string
}

Describes a local gateway virtual interface.

type LocalGatewayVirtualInterfaceGroup 

type LocalGatewayVirtualInterfaceGroup struct {
	// The ID of the virtual interface group.
	LocalGatewayVirtualInterfaceGroupId *string
	// The ID of the local gateway.
	LocalGatewayId *string
	// The IDs of the virtual interfaces.
	LocalGatewayVirtualInterfaceIds []*string
	// The tags assigned to the virtual interface group.
	Tags []*Tag
}

Describes a local gateway virtual interface group.

type LocationType 

type LocationType string
const (
	LocationTypeRegion             LocationType = "region"
	LocationTypeAvailabilityZone   LocationType = "availability-zone"
	LocationTypeAvailabilityZoneId LocationType = "availability-zone-id"
)

Enum values for LocationType

type LogDestinationType 

type LogDestinationType string
const (
	LogDestinationTypeCloudWatchLogs LogDestinationType = "cloud-watch-logs"
	LogDestinationTypeS3             LogDestinationType = "s3"
)

Enum values for LogDestinationType

type ManagedPrefixList 

type ManagedPrefixList struct {
	// The state message.
	StateMessage *string
	// The ID of the prefix list.
	PrefixListId *string
	// The ID of the owner of the prefix list.
	OwnerId *string
	// The name of the prefix list.
	PrefixListName *string
	// The Amazon Resource Name (ARN) for the prefix list.
	PrefixListArn *string
	// The maximum number of entries for the prefix list.
	MaxEntries *int32
	// The tags for the prefix list.
	Tags []*Tag
	// The IP address version.
	AddressFamily *string
	// The version of the prefix list.
	Version *int64
	// The state of the prefix list.
	State PrefixListState
}

Describes a managed prefix list.

type MarketType 

type MarketType string
const (
	MarketTypeSpot MarketType = "spot"
)

Enum values for MarketType

type MembershipType 

type MembershipType string
const (
	MembershipTypeStatic MembershipType = "static"
	MembershipTypeIgmp   MembershipType = "igmp"
)

Enum values for MembershipType

type MemoryInfo 

type MemoryInfo struct {
	// Size of the memory, in MiB.
	SizeInMiB *int64
}

Describes the memory for the instance type.

type ModifyAvailabilityZoneOptInStatus 

type ModifyAvailabilityZoneOptInStatus string
const (
	ModifyAvailabilityZoneOptInStatusOptedIn    ModifyAvailabilityZoneOptInStatus = "opted-in"
	ModifyAvailabilityZoneOptInStatusNotOptedIn ModifyAvailabilityZoneOptInStatus = "not-opted-in"
)

Enum values for ModifyAvailabilityZoneOptInStatus

type ModifyTransitGatewayVpcAttachmentRequestOptions 

type ModifyTransitGatewayVpcAttachmentRequestOptions struct {
	// Enable or disable DNS support. The default is enable.
	DnsSupport DnsSupportValue
	// Enable or disable IPv6 support. The default is enable.
	Ipv6Support Ipv6SupportValue
}

Describes the options for a VPC attachment.

type ModifyVpnTunnelOptionsSpecification 

type ModifyVpnTunnelOptionsSpecification struct {
	// The lifetime for phase 2 of the IKE negotiation, in seconds. Constraints: A
	// value between 900 and 3,600. The value must be less than the value for
	// Phase1LifetimeSeconds. Default: 3600
	Phase2LifetimeSeconds *int32
	// One or more integrity algorithms that are permitted for the VPN tunnel for phase
	// 1 IKE negotiations. Valid values: SHA1 | SHA2-256
	Phase1IntegrityAlgorithms []*Phase1IntegrityAlgorithmsRequestListValue
	// One or more integrity algorithms that are permitted for the VPN tunnel for phase
	// 2 IKE negotiations. Valid values: SHA1 | SHA2-256
	Phase2IntegrityAlgorithms []*Phase2IntegrityAlgorithmsRequestListValue
	// The pre-shared key (PSK) to establish initial authentication between the virtual
	// private gateway and the customer gateway. Constraints: Allowed characters are
	// alphanumeric characters, periods (.), and underscores (_). Must be between 8 and
	// 64 characters in length and cannot start with zero (0).
	PreSharedKey *string
	// One or more encryption algorithms that are permitted for the VPN tunnel for
	// phase 2 IKE negotiations. Valid values: AES128 | AES256
	Phase2EncryptionAlgorithms []*Phase2EncryptionAlgorithmsRequestListValue
	// One or more encryption algorithms that are permitted for the VPN tunnel for
	// phase 1 IKE negotiations. Valid values: AES128 | AES256
	Phase1EncryptionAlgorithms []*Phase1EncryptionAlgorithmsRequestListValue
	// The margin time, in seconds, before the phase 2 lifetime expires, during which
	// the AWS side of the VPN connection performs an IKE rekey. The exact time of the
	// rekey is randomly selected based on the value for RekeyFuzzPercentage.
	// Constraints: A value between 60 and half of Phase2LifetimeSeconds. Default: 540
	RekeyMarginTimeSeconds *int32
	// The number of seconds after which a DPD timeout occurs. Constraints: A value
	// between 0 and 30. Default: 30
	DPDTimeoutSeconds *int32
	// The number of packets in an IKE replay window. Constraints: A value between 64
	// and 2048. Default: 1024
	ReplayWindowSize *int32
	// One or more Diffie-Hellman group numbers that are permitted for the VPN tunnel
	// for phase 2 IKE negotiations. Valid values: 2 | 5 | 14 | 15 | 16 | 17 | 18 | 22
	// | 23 | 24
	Phase2DHGroupNumbers []*Phase2DHGroupNumbersRequestListValue
	// The percentage of the rekey window (determined by RekeyMarginTimeSeconds) during
	// which the rekey time is randomly selected. Constraints: A value between 0 and
	// 100. Default: 100
	RekeyFuzzPercentage *int32
	// The lifetime for phase 1 of the IKE negotiation, in seconds. Constraints: A
	// value between 900 and 28,800. Default: 28800
	Phase1LifetimeSeconds *int32
	// The range of inside IP addresses for the tunnel. Any specified CIDR blocks must
	// be unique across all VPN connections that use the same virtual private gateway.
	// Constraints: A size /30 CIDR block from the 169.254.0.0/16 range. The following
	// CIDR blocks are reserved and cannot be used:
	//
	//     * 169.254.0.0/30
	//
	//     *
	// 169.254.1.0/30
	//
	//     * 169.254.2.0/30
	//
	//     * 169.254.3.0/30
	//
	//     *
	// 169.254.4.0/30
	//
	//     * 169.254.5.0/30
	//
	//     * 169.254.169.252/30
	TunnelInsideCidr *string
	// One or more Diffie-Hellman group numbers that are permitted for the VPN tunnel
	// for phase 1 IKE negotiations. Valid values: 2 | 14 | 15 | 16 | 17 | 18 | 22 | 23
	// | 24
	Phase1DHGroupNumbers []*Phase1DHGroupNumbersRequestListValue
	// The IKE versions that are permitted for the VPN tunnel. Valid values: ikev1 |
	// ikev2
	IKEVersions []*IKEVersionsRequestListValue
}

The AWS Site-to-Site VPN tunnel options to modify.

type Monitoring 

type Monitoring struct {
	// Indicates whether detailed monitoring is enabled. Otherwise, basic monitoring is
	// enabled.
	State MonitoringState
}

Describes the monitoring of an instance.

type MonitoringState 

type MonitoringState string
const (
	MonitoringStateDisabled  MonitoringState = "disabled"
	MonitoringStateDisabling MonitoringState = "disabling"
	MonitoringStateEnabled   MonitoringState = "enabled"
	MonitoringStatePending   MonitoringState = "pending"
)

Enum values for MonitoringState

type MoveStatus 

type MoveStatus string
const (
	MoveStatusMovingtovpc        MoveStatus = "movingToVpc"
	MoveStatusRestoringtoclassic MoveStatus = "restoringToClassic"
)

Enum values for MoveStatus

type MovingAddressStatus 

type MovingAddressStatus struct {
	// The Elastic IP address.
	PublicIp *string
	// The status of the Elastic IP address that's being moved to the EC2-VPC platform,
	// or restored to the EC2-Classic platform.
	MoveStatus MoveStatus
}

Describes the status of a moving Elastic IP address.

type MulticastSupportValue 

type MulticastSupportValue string
const (
	MulticastSupportValueEnable  MulticastSupportValue = "enable"
	MulticastSupportValueDisable MulticastSupportValue = "disable"
)

Enum values for MulticastSupportValue

type NatGateway 

type NatGateway struct {
	// The ID of the VPC in which the NAT gateway is located.
	VpcId *string
	// If the NAT gateway could not be created, specifies the error code for the
	// failure. (InsufficientFreeAddressesInSubnet | Gateway.NotAttached |
	// InvalidAllocationID.NotFound | Resource.AlreadyAssociated | InternalError |
	// InvalidSubnetID.NotFound)
	FailureCode *string
	// The tags for the NAT gateway.
	Tags []*Tag
	// The ID of the subnet in which the NAT gateway is located.
	SubnetId *string
	// Information about the IP addresses and network interface associated with the NAT
	// gateway.
	NatGatewayAddresses []*NatGatewayAddress
	// The date and time the NAT gateway was created.
	CreateTime *time.Time
	// The date and time the NAT gateway was deleted, if applicable.
	DeleteTime *time.Time
	// The ID of the NAT gateway.
	NatGatewayId *string
	// If the NAT gateway could not be created, specifies the error message for the
	// failure, that corresponds to the error code.
	//
	//     * For
	// InsufficientFreeAddressesInSubnet: "Subnet has insufficient free addresses to
	// create this NAT gateway"
	//
	//     * For Gateway.NotAttached: "Network vpc-xxxxxxxx
	// has no Internet gateway attached"
	//
	//     * For InvalidAllocationID.NotFound:
	// "Elastic IP address eipalloc-xxxxxxxx could not be associated with this NAT
	// gateway"
	//
	//     * For Resource.AlreadyAssociated: "Elastic IP address
	// eipalloc-xxxxxxxx is already associated"
	//
	//     * For InternalError: "Network
	// interface eni-xxxxxxxx, created and used internally by this NAT gateway is in an
	// invalid state. Please try again."
	//
	//     * For InvalidSubnetID.NotFound: "The
	// specified subnet subnet-xxxxxxxx does not exist or could not be found."
	FailureMessage *string
	// The state of the NAT gateway.
	//
	//     * pending: The NAT gateway is being created
	// and is not ready to process traffic.
	//
	//     * failed: The NAT gateway could not be
	// created. Check the failureCode and failureMessage fields for the reason.
	//
	//     *
	// available: The NAT gateway is able to process traffic. This status remains until
	// you delete the NAT gateway, and does not indicate the health of the NAT
	// gateway.
	//
	//     * deleting: The NAT gateway is in the process of being terminated
	// and may still be processing traffic.
	//
	//     * deleted: The NAT gateway has been
	// terminated and is no longer processing traffic.
	State NatGatewayState
	// Reserved. If you need to sustain traffic greater than the documented limits
	// (https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html), contact
	// us through the Support Center (https://console.aws.amazon.com/support/home?).
	ProvisionedBandwidth *ProvisionedBandwidth
}

Describes a NAT gateway.

type NatGatewayAddress 

type NatGatewayAddress struct {
	// The ID of the network interface associated with the NAT gateway.
	NetworkInterfaceId *string
	// The private IP address associated with the Elastic IP address.
	PrivateIp *string
	// The Elastic IP address associated with the NAT gateway.
	PublicIp *string
	// The allocation ID of the Elastic IP address that's associated with the NAT
	// gateway.
	AllocationId *string
}

Describes the IP addresses and network interface associated with a NAT gateway.

type NatGatewayState 

type NatGatewayState string
const (
	NatGatewayStatePending   NatGatewayState = "pending"
	NatGatewayStateFailed    NatGatewayState = "failed"
	NatGatewayStateAvailable NatGatewayState = "available"
	NatGatewayStateDeleting  NatGatewayState = "deleting"
	NatGatewayStateDeleted   NatGatewayState = "deleted"
)

Enum values for NatGatewayState

type NetworkAcl 

type NetworkAcl struct {
	// Any tags assigned to the network ACL.
	Tags []*Tag
	// Indicates whether this is the default network ACL for the VPC.
	IsDefault *bool
	// One or more entries (rules) in the network ACL.
	Entries []*NetworkAclEntry
	// The ID of the AWS account that owns the network ACL.
	OwnerId *string
	// The ID of the VPC for the network ACL.
	VpcId *string
	// The ID of the network ACL.
	NetworkAclId *string
	// Any associations between the network ACL and one or more subnets
	Associations []*NetworkAclAssociation
}

Describes a network ACL.

type NetworkAclAssociation 

type NetworkAclAssociation struct {
	// The ID of the association between a network ACL and a subnet.
	NetworkAclAssociationId *string
	// The ID of the subnet.
	SubnetId *string
	// The ID of the network ACL.
	NetworkAclId *string
}

Describes an association between a network ACL and a subnet.

type NetworkAclEntry 

type NetworkAclEntry struct {
	// ICMP protocol: The ICMP type and code.
	IcmpTypeCode *IcmpTypeCode
	// The protocol number. A value of "-1" means all protocols.
	Protocol *string
	// Indicates whether to allow or deny the traffic that matches the rule.
	RuleAction RuleAction
	// The rule number for the entry. ACL entries are processed in ascending order by
	// rule number.
	RuleNumber *int32
	// Indicates whether the rule is an egress rule (applied to traffic leaving the
	// subnet).
	Egress *bool
	// The IPv6 network range to allow or deny, in CIDR notation.
	Ipv6CidrBlock *string
	// The IPv4 network range to allow or deny, in CIDR notation.
	CidrBlock *string
	// TCP or UDP protocols: The range of ports the rule applies to.
	PortRange *PortRange
}

Describes an entry in a network ACL.

type NetworkInfo 

type NetworkInfo struct {
	// Indicates whether Elastic Network Adapter (ENA) is supported.
	EnaSupport EnaSupport
	// The maximum number of IPv4 addresses per network interface.
	Ipv4AddressesPerInterface *int32
	// Indicates whether IPv6 is supported.
	Ipv6Supported *bool
	// The maximum number of IPv6 addresses per network interface.
	Ipv6AddressesPerInterface *int32
	// Indicates whether Elastic Fabric Adapter (EFA) is supported.
	EfaSupported *bool
	// The maximum number of network interfaces for the instance type.
	MaximumNetworkInterfaces *int32
	// Describes the network performance.
	NetworkPerformance *string
}

Describes the networking features of the instance type.

type NetworkInterface 

type NetworkInterface struct {
	// Any security groups for the network interface.
	Groups []*GroupIdentifier
	// Indicates whether the network interface is being managed by AWS.
	RequesterManaged *bool
	// The association information for an Elastic IP address (IPv4) associated with the
	// network interface.
	Association *NetworkInterfaceAssociation
	// The ID of the VPC.
	VpcId *string
	// The Availability Zone.
	AvailabilityZone *string
	// The AWS account ID of the owner of the network interface.
	OwnerId *string
	// The ID of the subnet.
	SubnetId *string
	// The private IPv4 addresses associated with the network interface.
	PrivateIpAddresses []*NetworkInterfacePrivateIpAddress
	// Indicates whether traffic to or from the instance is validated.
	SourceDestCheck *bool
	// The type of network interface.
	InterfaceType NetworkInterfaceType
	// A description.
	Description *string
	// The IPv4 address of the network interface within the subnet.
	PrivateIpAddress *string
	// The status of the network interface.
	Status NetworkInterfaceStatus
	// The IPv6 addresses associated with the network interface.
	Ipv6Addresses []*NetworkInterfaceIpv6Address
	// The ID of the entity that launched the instance on your behalf (for example, AWS
	// Management Console or Auto Scaling).
	RequesterId *string
	// The network interface attachment.
	Attachment *NetworkInterfaceAttachment
	// The private DNS name.
	PrivateDnsName *string
	// The ID of the network interface.
	NetworkInterfaceId *string
	// The MAC address.
	MacAddress *string
	// Any tags assigned to the network interface.
	TagSet []*Tag
	// The Amazon Resource Name (ARN) of the Outpost.
	OutpostArn *string
}

Describes a network interface.

type NetworkInterfaceAssociation 

type NetworkInterfaceAssociation struct {
	// The public DNS name.
	PublicDnsName *string
	// The ID of the Elastic IP address owner.
	IpOwnerId *string
	// The address of the Elastic IP address bound to the network interface.
	PublicIp *string
	// The allocation ID.
	AllocationId *string
	// The association ID.
	AssociationId *string
}

Describes association information for an Elastic IP address (IPv4 only).

type NetworkInterfaceAttachment 

type NetworkInterfaceAttachment struct {
	// The ID of the instance.
	InstanceId *string
	// The ID of the network interface attachment.
	AttachmentId *string
	// The attachment state.
	Status AttachmentStatus
	// The AWS account ID of the owner of the instance.
	InstanceOwnerId *string
	// The timestamp indicating when the attachment initiated.
	AttachTime *time.Time
	// The device index of the network interface attachment on the instance.
	DeviceIndex *int32
	// Indicates whether the network interface is deleted when the instance is
	// terminated.
	DeleteOnTermination *bool
}

Describes a network interface attachment.

type NetworkInterfaceAttachmentChanges 

type NetworkInterfaceAttachmentChanges struct {
	// Indicates whether the network interface is deleted when the instance is
	// terminated.
	DeleteOnTermination *bool
	// The ID of the network interface attachment.
	AttachmentId *string
}

Describes an attachment change.

type NetworkInterfaceAttribute 

type NetworkInterfaceAttribute string
const (
	NetworkInterfaceAttributeDescription     NetworkInterfaceAttribute = "description"
	NetworkInterfaceAttributeGroupset        NetworkInterfaceAttribute = "groupSet"
	NetworkInterfaceAttributeSourcedestcheck NetworkInterfaceAttribute = "sourceDestCheck"
	NetworkInterfaceAttributeAttachment      NetworkInterfaceAttribute = "attachment"
)

Enum values for NetworkInterfaceAttribute

type NetworkInterfaceCreationType 

type NetworkInterfaceCreationType string
const (
	NetworkInterfaceCreationTypeEfa NetworkInterfaceCreationType = "efa"
)

Enum values for NetworkInterfaceCreationType

type NetworkInterfaceIpv6Address 

type NetworkInterfaceIpv6Address struct {
	// The IPv6 address.
	Ipv6Address *string
}

Describes an IPv6 address associated with a network interface.

type NetworkInterfacePermission 

type NetworkInterfacePermission struct {
	// The AWS account ID.
	AwsAccountId *string
	// The ID of the network interface permission.
	NetworkInterfacePermissionId *string
	// The AWS service.
	AwsService *string
	// Information about the state of the permission.
	PermissionState *NetworkInterfacePermissionState
	// The type of permission.
	Permission InterfacePermissionType
	// The ID of the network interface.
	NetworkInterfaceId *string
}

Describes a permission for a network interface.

type NetworkInterfacePermissionState 

type NetworkInterfacePermissionState struct {
	// A status message, if applicable.
	StatusMessage *string
	// The state of the permission.
	State NetworkInterfacePermissionStateCode
}

Describes the state of a network interface permission.

type NetworkInterfacePermissionStateCode 

type NetworkInterfacePermissionStateCode string
const (
	NetworkInterfacePermissionStateCodePending  NetworkInterfacePermissionStateCode = "pending"
	NetworkInterfacePermissionStateCodeGranted  NetworkInterfacePermissionStateCode = "granted"
	NetworkInterfacePermissionStateCodeRevoking NetworkInterfacePermissionStateCode = "revoking"
	NetworkInterfacePermissionStateCodeRevoked  NetworkInterfacePermissionStateCode = "revoked"
)

Enum values for NetworkInterfacePermissionStateCode

type NetworkInterfacePrivateIpAddress 

type NetworkInterfacePrivateIpAddress struct {
	// The association information for an Elastic IP address (IPv4) associated with the
	// network interface.
	Association *NetworkInterfaceAssociation
	// The private DNS name.
	PrivateDnsName *string
	// Indicates whether this IPv4 address is the primary private IPv4 address of the
	// network interface.
	Primary *bool
	// The private IPv4 address.
	PrivateIpAddress *string
}

Describes the private IPv4 address of a network interface.

type NetworkInterfaceStatus 

type NetworkInterfaceStatus string
const (
	NetworkInterfaceStatusAvailable  NetworkInterfaceStatus = "available"
	NetworkInterfaceStatusAssociated NetworkInterfaceStatus = "associated"
	NetworkInterfaceStatusAttaching  NetworkInterfaceStatus = "attaching"
	NetworkInterfaceStatusInUse      NetworkInterfaceStatus = "in-use"
	NetworkInterfaceStatusDetaching  NetworkInterfaceStatus = "detaching"
)

Enum values for NetworkInterfaceStatus

type NetworkInterfaceType 

type NetworkInterfaceType string
const (
	NetworkInterfaceTypeInterface  NetworkInterfaceType = "interface"
	NetworkInterfaceTypeNatgateway NetworkInterfaceType = "natGateway"
	NetworkInterfaceTypeEfa        NetworkInterfaceType = "efa"
)

Enum values for NetworkInterfaceType

type NewDhcpConfiguration 

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

Describes a DHCP configuration option.

type OfferingClassType 

type OfferingClassType string
const (
	OfferingClassTypeStandard    OfferingClassType = "standard"
	OfferingClassTypeConvertible OfferingClassType = "convertible"
)

Enum values for OfferingClassType

type OfferingTypeValues 

type OfferingTypeValues string
const (
	OfferingTypeValuesHeavyUtilization  OfferingTypeValues = "Heavy Utilization"
	OfferingTypeValuesMediumUtilization OfferingTypeValues = "Medium Utilization"
	OfferingTypeValuesLightUtilization  OfferingTypeValues = "Light Utilization"
	OfferingTypeValuesNoUpfront         OfferingTypeValues = "No Upfront"
	OfferingTypeValuesPartialUpfront    OfferingTypeValues = "Partial Upfront"
	OfferingTypeValuesAllUpfront        OfferingTypeValues = "All Upfront"
)

Enum values for OfferingTypeValues

type OnDemandAllocationStrategy 

type OnDemandAllocationStrategy string
const (
	OnDemandAllocationStrategyLowest_price OnDemandAllocationStrategy = "lowestPrice"
	OnDemandAllocationStrategyPrioritized  OnDemandAllocationStrategy = "prioritized"
)

Enum values for OnDemandAllocationStrategy

type OnDemandOptions 

type OnDemandOptions struct {
	// The strategy for using unused Capacity Reservations for fulfilling On-Demand
	// capacity. Supported only for fleets of type instant.
	CapacityReservationOptions *CapacityReservationOptions
	// The maximum amount per hour for On-Demand Instances that you're willing to pay.
	MaxTotalPrice *string
	// Indicates that the fleet launches all On-Demand Instances into a single
	// Availability Zone. Supported only for fleets of type instant.
	SingleAvailabilityZone *bool
	// The minimum target capacity for On-Demand Instances in the fleet. If the minimum
	// target capacity is not reached, the fleet launches no instances.
	MinTargetCapacity *int32
	// Indicates that the fleet uses a single instance type to launch all On-Demand
	// Instances in the fleet. Supported only for fleets of type instant.
	SingleInstanceType *bool
	// The order of the launch template overrides to use in fulfilling On-Demand
	// capacity. If you specify lowest-price, EC2 Fleet uses price to determine the
	// order, launching the lowest price first. If you specify prioritized, EC2 Fleet
	// uses the priority that you assigned to each launch template override, launching
	// the highest priority first. If you do not specify a value, EC2 Fleet defaults to
	// lowest-price.
	AllocationStrategy FleetOnDemandAllocationStrategy
}

Describes the configuration of On-Demand Instances in an EC2 Fleet.

type OnDemandOptionsRequest 

type OnDemandOptionsRequest struct {
	// The order of the launch template overrides to use in fulfilling On-Demand
	// capacity. If you specify lowest-price, EC2 Fleet uses price to determine the
	// order, launching the lowest price first. If you specify prioritized, EC2 Fleet
	// uses the priority that you assigned to each launch template override, launching
	// the highest priority first. If you do not specify a value, EC2 Fleet defaults to
	// lowest-price.
	AllocationStrategy FleetOnDemandAllocationStrategy
	// The minimum target capacity for On-Demand Instances in the fleet. If the minimum
	// target capacity is not reached, the fleet launches no instances.
	MinTargetCapacity *int32
	// The maximum amount per hour for On-Demand Instances that you're willing to pay.
	MaxTotalPrice *string
	// Indicates that the fleet uses a single instance type to launch all On-Demand
	// Instances in the fleet. Supported only for fleets of type instant.
	SingleInstanceType *bool
	// Indicates that the fleet launches all On-Demand Instances into a single
	// Availability Zone. Supported only for fleets of type instant.
	SingleAvailabilityZone *bool
	// The strategy for using unused Capacity Reservations for fulfilling On-Demand
	// capacity. Supported only for fleets of type instant.
	CapacityReservationOptions *CapacityReservationOptionsRequest
}

Describes the configuration of On-Demand Instances in an EC2 Fleet.

type OperationType 

type OperationType string
const (
	OperationTypeAdd    OperationType = "add"
	OperationTypeRemove OperationType = "remove"
)

Enum values for OperationType

type PaymentOption 

type PaymentOption string
const (
	PaymentOptionAll_upfront     PaymentOption = "AllUpfront"
	PaymentOptionPartial_upfront PaymentOption = "PartialUpfront"
	PaymentOptionNo_upfront      PaymentOption = "NoUpfront"
)

Enum values for PaymentOption

type PciId 

type PciId struct {
	// The ID of the vendor.
	VendorId *string
	// The ID of the device.
	DeviceId *string
	// The ID of the vendor for the subsystem.
	SubsystemVendorId *string
	// The ID of the subsystem.
	SubsystemId *string
}

Describes the data that identifies an Amazon FPGA image (AFI) on the PCI bus.

type PeeringAttachmentStatus 

type PeeringAttachmentStatus struct {
	// The status code.
	Code *string
	// The status message, if applicable.
	Message *string
}

The status of the transit gateway peering attachment.

type PeeringConnectionOptions 

type PeeringConnectionOptions struct {
	// If true, enables outbound communication from an EC2-Classic instance that's
	// linked to a local VPC using ClassicLink to instances in a peer VPC.
	AllowEgressFromLocalClassicLinkToRemoteVpc *bool
	// If true, enables outbound communication from instances in a local VPC to an
	// EC2-Classic instance that's linked to a peer VPC using ClassicLink.
	AllowEgressFromLocalVpcToRemoteClassicLink *bool
	// If true, the public DNS hostnames of instances in the specified VPC resolve to
	// private IP addresses when queried from instances in the peer VPC.
	AllowDnsResolutionFromRemoteVpc *bool
}

Describes the VPC peering connection options.

type PeeringConnectionOptionsRequest 

type PeeringConnectionOptionsRequest struct {
	// If true, enables a local VPC to resolve public DNS hostnames to private IP
	// addresses when queried from instances in the peer VPC.
	AllowDnsResolutionFromRemoteVpc *bool
	// If true, enables outbound communication from an EC2-Classic instance that's
	// linked to a local VPC using ClassicLink to instances in a peer VPC.
	AllowEgressFromLocalClassicLinkToRemoteVpc *bool
	// If true, enables outbound communication from instances in a local VPC to an
	// EC2-Classic instance that's linked to a peer VPC using ClassicLink.
	AllowEgressFromLocalVpcToRemoteClassicLink *bool
}

The VPC peering connection options.

type PeeringTgwInfo 

type PeeringTgwInfo struct {
	// The AWS account ID of the owner of the transit gateway.
	OwnerId *string
	// The Region of the transit gateway.
	Region *string
	// The ID of the transit gateway.
	TransitGatewayId *string
}

Information about the transit gateway in the peering attachment.

type PermissionGroup 

type PermissionGroup string
const (
	PermissionGroupAll PermissionGroup = "all"
)

Enum values for PermissionGroup

type Phase1DHGroupNumbersListValue 

type Phase1DHGroupNumbersListValue struct {
	// The Diffie-Hellmann group number.
	Value *int32
}

The Diffie-Hellmann group number for phase 1 IKE negotiations.

type Phase1DHGroupNumbersRequestListValue 

type Phase1DHGroupNumbersRequestListValue struct {
	// The Diffie-Hellmann group number.
	Value *int32
}

Specifies a Diffie-Hellman group number for the VPN tunnel for phase 1 IKE negotiations.

type Phase1EncryptionAlgorithmsListValue 

type Phase1EncryptionAlgorithmsListValue struct {
	// The value for the encryption algorithm.
	Value *string
}

The encryption algorithm for phase 1 IKE negotiations.

type Phase1EncryptionAlgorithmsRequestListValue 

type Phase1EncryptionAlgorithmsRequestListValue struct {
	// The value for the encryption algorithm.
	Value *string
}

Specifies the encryption algorithm for the VPN tunnel for phase 1 IKE negotiations.

type Phase1IntegrityAlgorithmsListValue 

type Phase1IntegrityAlgorithmsListValue struct {
	// The value for the integrity algorithm.
	Value *string
}

The integrity algorithm for phase 1 IKE negotiations.

type Phase1IntegrityAlgorithmsRequestListValue 

type Phase1IntegrityAlgorithmsRequestListValue struct {
	// The value for the integrity algorithm.
	Value *string
}

Specifies the integrity algorithm for the VPN tunnel for phase 1 IKE negotiations.

type Phase2DHGroupNumbersListValue 

type Phase2DHGroupNumbersListValue struct {
	// The Diffie-Hellmann group number.
	Value *int32
}

The Diffie-Hellmann group number for phase 2 IKE negotiations.

type Phase2DHGroupNumbersRequestListValue 

type Phase2DHGroupNumbersRequestListValue struct {
	// The Diffie-Hellmann group number.
	Value *int32
}

Specifies a Diffie-Hellman group number for the VPN tunnel for phase 2 IKE negotiations.

type Phase2EncryptionAlgorithmsListValue 

type Phase2EncryptionAlgorithmsListValue struct {
	// The encryption algorithm.
	Value *string
}

The encryption algorithm for phase 2 IKE negotiations.

type Phase2EncryptionAlgorithmsRequestListValue 

type Phase2EncryptionAlgorithmsRequestListValue struct {
	// The encryption algorithm.
	Value *string
}

Specifies the encryption algorithm for the VPN tunnel for phase 2 IKE negotiations.

type Phase2IntegrityAlgorithmsListValue 

type Phase2IntegrityAlgorithmsListValue struct {
	// The integrity algorithm.
	Value *string
}

The integrity algorithm for phase 2 IKE negotiations.

type Phase2IntegrityAlgorithmsRequestListValue 

type Phase2IntegrityAlgorithmsRequestListValue struct {
	// The integrity algorithm.
	Value *string
}

Specifies the integrity algorithm for the VPN tunnel for phase 2 IKE negotiations.

type Placement 

type Placement struct {
	// Reserved for future use. This parameter is not supported by CreateFleet
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet).
	SpreadDomain *string
	// The number of the partition the instance is in. Valid only if the placement
	// group strategy is set to partition. This parameter is not supported by
	// CreateFleet
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet).
	PartitionNumber *int32
	// The affinity setting for the instance on the Dedicated Host. This parameter is
	// not supported for the ImportInstance
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportInstance.html)
	// command. This parameter is not supported by CreateFleet
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet).
	Affinity *string
	// The name of the placement group the instance is in.
	GroupName *string
	// The Availability Zone of the instance. If not specified, an Availability Zone
	// will be automatically chosen for you based on the load balancing criteria for
	// the Region. This parameter is not supported by CreateFleet
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet).
	AvailabilityZone *string
	// The ID of the Dedicated Host on which the instance resides. This parameter is
	// not supported for the ImportInstance
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportInstance.html)
	// command. This parameter is not supported by CreateFleet
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet).
	HostId *string
	// The ARN of the host resource group in which to launch the instances. If you
	// specify a host resource group ARN, omit the Tenancy parameter or set it to host.
	// This parameter is not supported by CreateFleet
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet).
	HostResourceGroupArn *string
	// The tenancy of the instance (if the instance is running in a VPC). An instance
	// with a tenancy of dedicated runs on single-tenant hardware. The host tenancy is
	// not supported for the ImportInstance
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportInstance.html)
	// command. This parameter is not supported by CreateFleet
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet).
	Tenancy Tenancy
}

Describes the placement of an instance.

type PlacementGroup 

type PlacementGroup struct {
	// The state of the placement group.
	State PlacementGroupState
	// The name of the placement group.
	GroupName *string
	// The number of partitions. Valid only if strategy is set to partition.
	PartitionCount *int32
	// Any tags applied to the placement group.
	Tags []*Tag
	// The ID of the placement group.
	GroupId *string
	// The placement strategy.
	Strategy PlacementStrategy
}

Describes a placement group.

type PlacementGroupInfo 

type PlacementGroupInfo struct {
	// A list of supported placement groups types.
	SupportedStrategies []PlacementGroupStrategy
}

Describes the placement group support of the instance type.

type PlacementGroupState 

type PlacementGroupState string
const (
	PlacementGroupStatePending   PlacementGroupState = "pending"
	PlacementGroupStateAvailable PlacementGroupState = "available"
	PlacementGroupStateDeleting  PlacementGroupState = "deleting"
	PlacementGroupStateDeleted   PlacementGroupState = "deleted"
)

Enum values for PlacementGroupState

type PlacementGroupStrategy 

type PlacementGroupStrategy string
const (
	PlacementGroupStrategyCluster   PlacementGroupStrategy = "cluster"
	PlacementGroupStrategyPartition PlacementGroupStrategy = "partition"
	PlacementGroupStrategySpread    PlacementGroupStrategy = "spread"
)

Enum values for PlacementGroupStrategy

type PlacementResponse 

type PlacementResponse struct {
	// The name of the placement group that the instance is in.
	GroupName *string
}

Describes the placement of an instance.

type PlacementStrategy 

type PlacementStrategy string
const (
	PlacementStrategyCluster   PlacementStrategy = "cluster"
	PlacementStrategySpread    PlacementStrategy = "spread"
	PlacementStrategyPartition PlacementStrategy = "partition"
)

Enum values for PlacementStrategy

type PlatformValues 

type PlatformValues string
const (
	PlatformValuesWindows PlatformValues = "Windows"
)

Enum values for PlatformValues

type PoolCidrBlock 

type PoolCidrBlock struct {
	// The CIDR block.
	Cidr *string
}

Describes a CIDR block for an address pool.

type PortRange 

type PortRange struct {
	// The first port in the range.
	From *int32
	// The last port in the range.
	To *int32
}

Describes a range of ports.

type PrefixList 

type PrefixList struct {
	// The IP address range of the AWS service.
	Cidrs []*string
	// The ID of the prefix.
	PrefixListId *string
	// The name of the prefix.
	PrefixListName *string
}

Describes prefixes for AWS services.

type PrefixListAssociation 

type PrefixListAssociation struct {
	// The owner of the resource.
	ResourceOwner *string
	// The ID of the resource.
	ResourceId *string
}

Describes the resource with which a prefix list is associated.

type PrefixListEntry 

type PrefixListEntry struct {
	// The CIDR block.
	Cidr *string
	// The description.
	Description *string
}

Describes a prefix list entry.

type PrefixListId 

type PrefixListId struct {
	// A description for the security group rule that references this prefix list ID.
	// Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z,
	// 0-9, spaces, and ._-:/()#,@[]+=;{}!$*
	Description *string
	// The ID of the prefix.
	PrefixListId *string
}

Describes a prefix list ID.

type PrefixListState 

type PrefixListState string
const (
	PrefixListStateCreateInProgress  PrefixListState = "create-in-progress"
	PrefixListStateCreateComplete    PrefixListState = "create-complete"
	PrefixListStateCreateFailed      PrefixListState = "create-failed"
	PrefixListStateModifyInProgress  PrefixListState = "modify-in-progress"
	PrefixListStateModifyComplete    PrefixListState = "modify-complete"
	PrefixListStateModifyFailed      PrefixListState = "modify-failed"
	PrefixListStateRestoreInProgress PrefixListState = "restore-in-progress"
	PrefixListStateRestoreComplete   PrefixListState = "restore-complete"
	PrefixListStateRestoreFailed     PrefixListState = "restore-failed"
	PrefixListStateDeleteInProgress  PrefixListState = "delete-in-progress"
	PrefixListStateDeleteComplete    PrefixListState = "delete-complete"
	PrefixListStateDeleteFailed      PrefixListState = "delete-failed"
)

Enum values for PrefixListState

type PriceSchedule 

type PriceSchedule struct {
	// The fixed price for the term.
	Price *float64
	// The currency for transacting the Reserved Instance resale. At this time, the
	// only supported currency is USD.
	CurrencyCode CurrencyCodeValues
	// The number of months remaining in the reservation. For example, 2 is the second
	// to the last month before the capacity reservation expires.
	Term *int64
	// The current price schedule, as determined by the term remaining for the Reserved
	// Instance in the listing. A specific price schedule is always in effect, but only
	// one price schedule can be active at any time. Take, for example, a Reserved
	// Instance listing that has five months remaining in its term. When you specify
	// price schedules for five months and two months, this means that schedule 1,
	// covering the first three months of the remaining term, will be active during
	// months 5, 4, and 3. Then schedule 2, covering the last two months of the term,
	// will be active for months 2 and 1.
	Active *bool
}

Describes the price for a Reserved Instance.

type PriceScheduleSpecification 

type PriceScheduleSpecification struct {
	// The number of months remaining in the reservation. For example, 2 is the second
	// to the last month before the capacity reservation expires.
	Term *int64
	// The currency for transacting the Reserved Instance resale. At this time, the
	// only supported currency is USD.
	CurrencyCode CurrencyCodeValues
	// The fixed price for the term.
	Price *float64
}

Describes the price for a Reserved Instance.

type PricingDetail 

type PricingDetail struct {
	// The number of reservations available for the price.
	Count *int32
	// The price per instance.
	Price *float64
}

Describes a Reserved Instance offering.

type PrincipalIdFormat 

type PrincipalIdFormat struct {
	// PrincipalIdFormatARN description
	Arn *string
	// PrincipalIdFormatStatuses description
	Statuses []*IdFormat
}

PrincipalIdFormat description

type PrincipalType 

type PrincipalType string
const (
	PrincipalTypeAll              PrincipalType = "All"
	PrincipalTypeService          PrincipalType = "Service"
	PrincipalTypeOrganizationunit PrincipalType = "OrganizationUnit"
	PrincipalTypeAccount          PrincipalType = "Account"
	PrincipalTypeUser             PrincipalType = "User"
	PrincipalTypeRole             PrincipalType = "Role"
)

Enum values for PrincipalType

type PrivateDnsNameConfiguration 

type PrivateDnsNameConfiguration struct {
	// The endpoint service verification type, for example TXT.
	Type *string
	// The verification state of the VPC endpoint service. >Consumers of the endpoint
	// service can use the private name only when the state is verified.
	State DnsNameState
	// The name of the record subdomain the service provider needs to create. The
	// service provider adds the value text to the name.
	Name *string
	// The value the service provider adds to the private DNS name domain record before
	// verification.
	Value *string
}

Information about the private DNS name for the service endpoint. For more information about these parameters, see VPC Endpoint Service Private DNS Name Verification (https://docs.aws.amazon.com/vpc/latest/userguide/ndpoint-services-dns-validation.html) in the Amazon Virtual Private Cloud User Guide.

type PrivateIpAddressSpecification 

type PrivateIpAddressSpecification struct {
	// Indicates whether the private IPv4 address is the primary private IPv4 address.
	// Only one IPv4 address can be designated as primary.
	Primary *bool
	// The private IPv4 addresses.
	PrivateIpAddress *string
}

Describes a secondary private IPv4 address for a network interface.

type ProcessorInfo 

type ProcessorInfo struct {
	// A list of architectures supported by the instance type.
	SupportedArchitectures []ArchitectureType
	// The speed of the processor, in GHz.
	SustainedClockSpeedInGhz *float64
}

Describes the processor used by the instance type.

type ProductCode 

type ProductCode struct {
	// The product code.
	ProductCodeId *string
	// The type of product code.
	ProductCodeType ProductCodeValues
}

Describes a product code.

type ProductCodeValues 

type ProductCodeValues string
const (
	ProductCodeValuesDevpay      ProductCodeValues = "devpay"
	ProductCodeValuesMarketplace ProductCodeValues = "marketplace"
)

Enum values for ProductCodeValues

type PropagatingVgw 

type PropagatingVgw struct {
	// The ID of the virtual private gateway.
	GatewayId *string
}

Describes a virtual private gateway propagating route.

type ProvisionedBandwidth 

type ProvisionedBandwidth struct {
	// Reserved. If you need to sustain traffic greater than the documented limits
	// (https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html), contact
	// us through the Support Center (https://console.aws.amazon.com/support/home?).
	Requested *string
	// Reserved. If you need to sustain traffic greater than the documented limits
	// (https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html), contact
	// us through the Support Center (https://console.aws.amazon.com/support/home?).
	RequestTime *time.Time
	// Reserved. If you need to sustain traffic greater than the documented limits
	// (https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html), contact
	// us through the Support Center (https://console.aws.amazon.com/support/home?).
	Status *string
	// Reserved. If you need to sustain traffic greater than the documented limits
	// (https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html), contact
	// us through the Support Center (https://console.aws.amazon.com/support/home?).
	ProvisionTime *time.Time
	// Reserved. If you need to sustain traffic greater than the documented limits
	// (https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html), contact
	// us through the Support Center (https://console.aws.amazon.com/support/home?).
	Provisioned *string
}

Reserved. If you need to sustain traffic greater than the documented limits (https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html), contact us through the Support Center (https://console.aws.amazon.com/support/home?).

type PublicIpv4Pool 

type PublicIpv4Pool struct {
	// The name of the location from which the address pool is advertised. A network
	// border group is a unique set of Availability Zones or Local Zones from where AWS
	// advertises public IP addresses.
	NetworkBorderGroup *string
	// The total number of addresses.
	TotalAddressCount *int32
	// The ID of the address pool.
	PoolId *string
	// The total number of available addresses.
	TotalAvailableAddressCount *int32
	// A description of the address pool.
	Description *string
	// The address ranges.
	PoolAddressRanges []*PublicIpv4PoolRange
	// Any tags for the address pool.
	Tags []*Tag
}

Describes an IPv4 address pool.

type PublicIpv4PoolRange 

type PublicIpv4PoolRange struct {
	// The last IP address in the range.
	LastAddress *string
	// The number of available addresses in the range.
	AvailableAddressCount *int32
	// The first IP address in the range.
	FirstAddress *string
	// The number of addresses in the range.
	AddressCount *int32
}

Describes an address range of an IPv4 address pool.

type Purchase 

type Purchase struct {
	// The payment option for the reservation.
	PaymentOption PaymentOption
	// The ID of the reservation.
	HostReservationId *string
	// The instance family on the Dedicated Host that the reservation can be associated
	// with.
	InstanceFamily *string
	// The IDs of the Dedicated Hosts associated with the reservation.
	HostIdSet []*string
	// The currency in which the UpfrontPrice and HourlyPrice amounts are specified. At
	// this time, the only supported currency is USD.
	CurrencyCode CurrencyCodeValues
	// The hourly price of the reservation per hour.
	HourlyPrice *string
	// The duration of the reservation's term in seconds.
	Duration *int32
	// The upfront price of the reservation.
	UpfrontPrice *string
}

Describes the result of the purchase.

type PurchaseRequest 

type PurchaseRequest struct {
	// The purchase token.
	PurchaseToken *string
	// The number of instances.
	InstanceCount *int32
}

Describes a request to purchase Scheduled Instances.

type RIProductDescription 

type RIProductDescription string
const (
	RIProductDescriptionLinuxUnix          RIProductDescription = "Linux/UNIX"
	RIProductDescriptionLinuxUnixAmazonVpc RIProductDescription = "Linux/UNIX (Amazon VPC)"
	RIProductDescriptionWindows            RIProductDescription = "Windows"
	RIProductDescriptionWindowsAmazonVpc   RIProductDescription = "Windows (Amazon VPC)"
)

Enum values for RIProductDescription

type RecurringCharge 

type RecurringCharge struct {
	// The frequency of the recurring charge.
	Frequency RecurringChargeFrequency
	// The amount of the recurring charge.
	Amount *float64
}

Describes a recurring charge.

type RecurringChargeFrequency 

type RecurringChargeFrequency string
const (
	RecurringChargeFrequencyHourly RecurringChargeFrequency = "Hourly"
)

Enum values for RecurringChargeFrequency

type Region 

type Region struct {
	// The Region opt-in status. The possible values are opt-in-not-required, opted-in,
	// and not-opted-in.
	OptInStatus *string
	// The name of the Region.
	RegionName *string
	// The Region service endpoint.
	Endpoint *string
}

Describes a Region.

type RegisterInstanceTagAttributeRequest 

type RegisterInstanceTagAttributeRequest struct {
	// The tag keys to register.
	InstanceTagKeys []*string
	// Indicates whether to register all tag keys in the current Region. Specify true
	// to register all tag keys.
	IncludeAllTagsOfInstance *bool
}

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

type RemovePrefixListEntry 

type RemovePrefixListEntry struct {
	// The CIDR block.
	Cidr *string
}

An entry for a prefix list.

type ReportInstanceReasonCodes 

type ReportInstanceReasonCodes string
const (
	ReportInstanceReasonCodesInstanceStuckInState     ReportInstanceReasonCodes = "instance-stuck-in-state"
	ReportInstanceReasonCodesUnresponsive             ReportInstanceReasonCodes = "unresponsive"
	ReportInstanceReasonCodesNotAcceptingCredentials  ReportInstanceReasonCodes = "not-accepting-credentials"
	ReportInstanceReasonCodesPasswordNotAvailable     ReportInstanceReasonCodes = "password-not-available"
	ReportInstanceReasonCodesPerformanceNetwork       ReportInstanceReasonCodes = "performance-network"
	ReportInstanceReasonCodesPerformanceInstanceStore ReportInstanceReasonCodes = "performance-instance-store"
	ReportInstanceReasonCodesPerformanceEbsVolume     ReportInstanceReasonCodes = "performance-ebs-volume"
	ReportInstanceReasonCodesPerformanceOther         ReportInstanceReasonCodes = "performance-other"
	ReportInstanceReasonCodesOther                    ReportInstanceReasonCodes = "other"
)

Enum values for ReportInstanceReasonCodes

type ReportStatusType 

type ReportStatusType string
const (
	ReportStatusTypeOk       ReportStatusType = "ok"
	ReportStatusTypeImpaired ReportStatusType = "impaired"
)

Enum values for ReportStatusType

type RequestLaunchTemplateData 

type RequestLaunchTemplateData struct {
	// One or more network interfaces. If you specify a network interface, you must
	// specify any security groups and subnets as part of the network interface.
	NetworkInterfaces []*LaunchTemplateInstanceNetworkInterfaceSpecificationRequest
	// The ID of the RAM disk. We recommend that you use PV-GRUB instead of kernels and
	// RAM disks. For more information, see User Provided Kernels
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html)
	// in the Amazon Elastic Compute Cloud User Guide.
	RamDiskId *string
	// Indicates whether an instance stops or terminates when you initiate shutdown
	// from the instance (using the operating system command for system shutdown).
	// Default: stop
	InstanceInitiatedShutdownBehavior ShutdownBehavior
	// If you set this parameter to true, you can't terminate the instance using the
	// Amazon EC2 console, CLI, or API; otherwise, you can. To change this attribute
	// after launch, use ModifyInstanceAttribute
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstanceAttribute.html).
	// Alternatively, if you set InstanceInitiatedShutdownBehavior to terminate, you
	// can terminate the instance by running the shutdown command from the instance.
	DisableApiTermination *bool
	// Indicates whether an instance is enabled 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 Elastic Compute Cloud User Guide.
	HibernationOptions *LaunchTemplateHibernationOptionsRequest
	// Indicates whether the instance is optimized for Amazon EBS I/O. This
	// optimization provides dedicated throughput to Amazon EBS and an optimized
	// configuration stack to provide optimal Amazon EBS 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 CPU options for the instance. For more information, see Optimizing CPU
	// Options
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-optimize-cpu.html)
	// in the Amazon Elastic Compute Cloud User Guide.
	CpuOptions *LaunchTemplateCpuOptionsRequest
	// One or more security group IDs. You can create a security group using
	// CreateSecurityGroup
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html).
	// You cannot specify both a security group ID and security name in the same
	// request.
	SecurityGroupIds []*string
	// The elastic inference accelerator for the instance.
	ElasticInferenceAccelerators []*LaunchTemplateElasticInferenceAccelerator
	// The license configurations.
	LicenseSpecifications []*LaunchTemplateLicenseConfigurationRequest
	// The credit option for CPU usage of the instance. Valid for T2, T3, or T3a
	// instances only.
	CreditSpecification *CreditSpecificationRequest
	// The metadata options for the instance. For more information, see Instance
	// Metadata and User Data
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html)
	// in the Amazon Elastic Compute Cloud User Guide.
	MetadataOptions *LaunchTemplateInstanceMetadataOptionsRequest
	// The Capacity Reservation targeting option. If you do not specify this parameter,
	// the instance's Capacity Reservation preference defaults to open, which enables
	// it to run in any open Capacity Reservation that has matching attributes
	// (instance type, platform, Availability Zone).
	CapacityReservationSpecification *LaunchTemplateCapacityReservationSpecificationRequest
	// The IAM instance profile.
	IamInstanceProfile *LaunchTemplateIamInstanceProfileSpecificationRequest
	// The block device mapping.
	BlockDeviceMappings []*LaunchTemplateBlockDeviceMappingRequest
	// The Base64-encoded user data to make available to the instance. For more
	// information, see Running Commands on Your Linux Instance at Launch
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html) (Linux) and
	// Adding User Data
	// (https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2-instance-metadata.html#instancedata-add-user-data)
	// (Windows).
	UserData *string
	// The name of the key pair. You can create a key pair using CreateKeyPair
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html)
	// or ImportKeyPair
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportKeyPair.html).
	// If you do not specify a key pair, you can't connect to the instance unless you
	// choose an AMI that is configured to allow users another way to log in.
	KeyName *string
	// The ID of the AMI.
	ImageId *string
	// [EC2-Classic, default VPC] One or more security group names. For a nondefault
	// VPC, you must use security group IDs instead. You cannot specify both a security
	// group ID and security name in the same request.
	SecurityGroups []*string
	// The market (purchasing) option for the instances.
	InstanceMarketOptions *LaunchTemplateInstanceMarketOptionsRequest
	// The ID of the kernel. We recommend that you use PV-GRUB instead of kernels and
	// RAM disks. For more information, see User Provided Kernels
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html)
	// in the Amazon Elastic Compute Cloud User Guide.
	KernelId *string
	// The tags to apply to the resources during launch. You can only tag instances and
	// volumes on launch. The specified tags are applied to all instances or volumes
	// that are created during launch. To tag a resource after it has been created, see
	// CreateTags
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTags.html).
	TagSpecifications []*LaunchTemplateTagSpecificationRequest
	// The placement for the instance.
	Placement *LaunchTemplatePlacementRequest
	// The instance type. For more information, see Instance Types
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) in the
	// Amazon Elastic Compute Cloud User Guide.
	InstanceType InstanceType
	// An elastic GPU to associate with the instance.
	ElasticGpuSpecifications []*ElasticGpuSpecification
	// The monitoring for the instance.
	Monitoring *LaunchTemplatesMonitoringRequest
}

The information to include in the launch template.

type RequestSpotLaunchSpecification 

type RequestSpotLaunchSpecification struct {
	// The ID of the RAM disk.
	RamdiskId *string
	// The ID of the AMI.
	ImageId *string
	// Indicates whether basic or detailed monitoring is enabled for the instance.
	// Default: Disabled
	Monitoring *RunInstancesMonitoringEnabled
	// The Base64-encoded user data for the instance. User data is limited to 16 KB.
	UserData *string
	// One or more security group IDs.
	SecurityGroupIds []*string
	// Indicates whether the instance is optimized for EBS I/O. This optimization
	// provides dedicated throughput to Amazon EBS and an optimized configuration stack
	// to provide optimal EBS I/O performance. This optimization isn't available with
	// all instance types. Additional usage charges apply when using an EBS Optimized
	// instance. Default: false
	EbsOptimized *bool
	// One or more security groups. When requesting instances in a VPC, you must
	// specify the IDs of the security groups. When requesting instances in
	// EC2-Classic, you can specify the names or the IDs of the security groups.
	SecurityGroups []*string
	// One or more network interfaces. If you specify a network interface, you must
	// specify subnet IDs and security group IDs using the network interface.
	NetworkInterfaces []*InstanceNetworkInterfaceSpecification
	// The placement information for the instance.
	Placement *SpotPlacement
	// The name of the key pair.
	KeyName *string
	// The instance type.
	InstanceType InstanceType
	// One or more block device mapping entries. You can't specify both a snapshot ID
	// and an encryption value. This is because only blank volumes can be encrypted on
	// creation. If a snapshot is the basis for a volume, it is not blank and its
	// encryption status is used for the volume encryption status.
	BlockDeviceMappings []*BlockDeviceMapping
	// The IAM instance profile.
	IamInstanceProfile *IamInstanceProfileSpecification
	// The ID of the kernel.
	KernelId *string
	// The IDs of the subnets in which to launch the instance. To specify multiple
	// subnets, separate them using commas; for example, "subnet-1234abcdeexample1,
	// subnet-0987cdef6example2".
	SubnetId *string
	// Deprecated.
	AddressingType *string
}

Describes the launch specification for an instance.

type Reservation 

type Reservation struct {
	// [EC2-Classic only] The security groups.
	Groups []*GroupIdentifier
	// The instances.
	Instances []*Instance
	// The ID of the requester that launched the instances on your behalf (for example,
	// AWS Management Console or Auto Scaling).
	RequesterId *string
	// The ID of the reservation.
	ReservationId *string
	// The ID of the AWS account that owns the reservation.
	OwnerId *string
}

Describes a reservation.

type ReservationState 

type ReservationState string
const (
	ReservationStatePayment_pending ReservationState = "payment-pending"
	ReservationStatePayment_failed  ReservationState = "payment-failed"
	ReservationStateActive          ReservationState = "active"
	ReservationStateRetired         ReservationState = "retired"
)

Enum values for ReservationState

type ReservationValue 

type ReservationValue struct {
	// The hourly rate of the reservation.
	HourlyPrice *string
	// The remaining upfront cost of the reservation.
	RemainingUpfrontValue *string
	// The balance of the total value (the sum of remainingUpfrontValue + hourlyPrice *
	// number of hours remaining).
	RemainingTotalValue *string
}

The cost associated with the Reserved Instance.

type ReservedInstanceLimitPrice 

type ReservedInstanceLimitPrice struct {
	// The currency in which the limitPrice amount is specified. At this time, the only
	// supported currency is USD.
	CurrencyCode CurrencyCodeValues
	// Used for Reserved Instance Marketplace offerings. Specifies the limit price on
	// the total order (instanceCount * price).
	Amount *float64
}

Describes the limit price of a Reserved Instance offering.

type ReservedInstanceReservationValue 

type ReservedInstanceReservationValue struct {
	// The ID of the Convertible Reserved Instance that you are exchanging.
	ReservedInstanceId *string
	// The total value of the Convertible Reserved Instance that you are exchanging.
	ReservationValue *ReservationValue
}

The total value of the Convertible Reserved Instance.

type ReservedInstanceState 

type ReservedInstanceState string
const (
	ReservedInstanceStatePaymentPending ReservedInstanceState = "payment-pending"
	ReservedInstanceStateActive         ReservedInstanceState = "active"
	ReservedInstanceStatePaymentFailed  ReservedInstanceState = "payment-failed"
	ReservedInstanceStateRetired        ReservedInstanceState = "retired"
	ReservedInstanceStateQueued         ReservedInstanceState = "queued"
	ReservedInstanceStateQueuedDeleted  ReservedInstanceState = "queued-deleted"
)

Enum values for ReservedInstanceState

type ReservedInstances 

type ReservedInstances struct {
	// The tenancy of the instance.
	InstanceTenancy Tenancy
	// Any tags assigned to the resource.
	Tags []*Tag
	// The Availability Zone in which the Reserved Instance can be used.
	AvailabilityZone *string
	// The state of the Reserved Instance purchase.
	State ReservedInstanceState
	// The usage price of the Reserved Instance, per hour.
	UsagePrice *float32
	// The ID of the Reserved Instance.
	ReservedInstancesId *string
	// The duration of the Reserved Instance, in seconds.
	Duration *int64
	// The scope of the Reserved Instance.
	Scope Scope
	// The time when the Reserved Instance expires.
	End *time.Time
	// The offering class of the Reserved Instance.
	OfferingClass OfferingClassType
	// The date and time the Reserved Instance started.
	Start *time.Time
	// The currency of the Reserved Instance. It's specified using ISO 4217 standard
	// currency codes. At this time, the only supported currency is USD.
	CurrencyCode CurrencyCodeValues
	// The Reserved Instance offering type.
	OfferingType OfferingTypeValues
	// The recurring charge tag assigned to the resource.
	RecurringCharges []*RecurringCharge
	// The purchase price of the Reserved Instance.
	FixedPrice *float32
	// The Reserved Instance product platform description.
	ProductDescription RIProductDescription
	// The number of reservations purchased.
	InstanceCount *int32
	// The instance type on which the Reserved Instance can be used.
	InstanceType InstanceType
}

Describes a Reserved Instance.

type ReservedInstancesConfiguration 

type ReservedInstancesConfiguration struct {
	// The network platform of the modified Reserved Instances, which is either
	// EC2-Classic or EC2-VPC.
	Platform *string
	// The instance type for the modified Reserved Instances.
	InstanceType InstanceType
	// Whether the Reserved Instance is applied to instances in a Region or instances
	// in a specific Availability Zone.
	Scope Scope
	// The number of modified Reserved Instances. This is a required field for a
	// request.
	InstanceCount *int32
	// The Availability Zone for the modified Reserved Instances.
	AvailabilityZone *string
}

Describes the configuration settings for the modified Reserved Instances.

type ReservedInstancesId 

type ReservedInstancesId struct {
	// The ID of the Reserved Instance.
	ReservedInstancesId *string
}

Describes the ID of a Reserved Instance.

type ReservedInstancesListing 

type ReservedInstancesListing struct {
	// The reason for the current status of the Reserved Instance listing. The response
	// can be blank.
	StatusMessage *string
	// The number of instances in this state.
	InstanceCounts []*InstanceCount
	// A unique, case-sensitive key supplied by the client to ensure that the request
	// is idempotent. For more information, see Ensuring Idempotency
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
	ClientToken *string
	// The ID of the Reserved Instance.
	ReservedInstancesId *string
	// The last modified timestamp of the listing.
	UpdateDate *time.Time
	// The status of the Reserved Instance listing.
	Status ListingStatus
	// Any tags assigned to the resource.
	Tags []*Tag
	// The time the listing was created.
	CreateDate *time.Time
	// The price of the Reserved Instance listing.
	PriceSchedules []*PriceSchedule
	// The ID of the Reserved Instance listing.
	ReservedInstancesListingId *string
}

Describes a Reserved Instance listing.

type ReservedInstancesModification 

type ReservedInstancesModification struct {
	// The IDs of one or more Reserved Instances.
	ReservedInstancesIds []*ReservedInstancesId
	// The status of the Reserved Instances modification request.
	Status *string
	// A unique, case-sensitive key supplied by the client to ensure that the request
	// is idempotent. For more information, see Ensuring Idempotency
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
	ClientToken *string
	// Contains target configurations along with their corresponding new Reserved
	// Instance IDs.
	ModificationResults []*ReservedInstancesModificationResult
	// The time for the modification to become effective.
	EffectiveDate *time.Time
	// The reason for the status.
	StatusMessage *string
	// The time when the modification request was created.
	CreateDate *time.Time
	// A unique ID for the Reserved Instance modification.
	ReservedInstancesModificationId *string
	// The time when the modification request was last updated.
	UpdateDate *time.Time
}

Describes a Reserved Instance modification.

type ReservedInstancesModificationResult 

type ReservedInstancesModificationResult struct {
	// The target Reserved Instances configurations supplied as part of the
	// modification request.
	TargetConfiguration *ReservedInstancesConfiguration
	// The ID for the Reserved Instances that were created as part of the modification
	// request. This field is only available when the modification is fulfilled.
	ReservedInstancesId *string
}

Describes the modification request/s.

type ReservedInstancesOffering 

type ReservedInstancesOffering struct {
	// The Availability Zone in which the Reserved Instance can be used.
	AvailabilityZone *string
	// If convertible it can be exchanged for Reserved Instances of the same or higher
	// monetary value, with different configurations. If standard, it is not possible
	// to perform an exchange.
	OfferingClass OfferingClassType
	// The Reserved Instance offering type.
	OfferingType OfferingTypeValues
	// The Reserved Instance product platform description.
	ProductDescription RIProductDescription
	// The pricing details of the Reserved Instance offering.
	PricingDetails []*PricingDetail
	// The recurring charge tag assigned to the resource.
	RecurringCharges []*RecurringCharge
	// Indicates whether the offering is available through the Reserved Instance
	// Marketplace (resale) or AWS. If it's a Reserved Instance Marketplace offering,
	// this is true.
	Marketplace *bool
	// Whether the Reserved Instance is applied to instances in a Region or an
	// Availability Zone.
	Scope Scope
	// The tenancy of the instance.
	InstanceTenancy Tenancy
	// The usage price of the Reserved Instance, per hour.
	UsagePrice *float32
	// The duration of the Reserved Instance, in seconds.
	Duration *int64
	// The instance type on which the Reserved Instance can be used.
	InstanceType InstanceType
	// The purchase price of the Reserved Instance.
	FixedPrice *float32
	// The currency of the Reserved Instance offering you are purchasing. It's
	// specified using ISO 4217 standard currency codes. At this time, the only
	// supported currency is USD.
	CurrencyCode CurrencyCodeValues
	// The ID of the Reserved Instance offering. This is the offering ID used in
	// GetReservedInstancesExchangeQuote () to confirm that an exchange can be made.
	ReservedInstancesOfferingId *string
}

Describes a Reserved Instance offering.

type ResetFpgaImageAttributeName 

type ResetFpgaImageAttributeName string
const (
	ResetFpgaImageAttributeNameLoadpermission ResetFpgaImageAttributeName = "loadPermission"
)

Enum values for ResetFpgaImageAttributeName

type ResetImageAttributeName 

type ResetImageAttributeName string
const (
	ResetImageAttributeNameLaunchpermission ResetImageAttributeName = "launchPermission"
)

Enum values for ResetImageAttributeName

type ResourceType 

type ResourceType string
const (
	ResourceTypeClientVpnEndpoint                    ResourceType = "client-vpn-endpoint"
	ResourceTypeCustomerGateway                      ResourceType = "customer-gateway"
	ResourceTypeDedicatedHost                        ResourceType = "dedicated-host"
	ResourceTypeDhcpOptions                          ResourceType = "dhcp-options"
	ResourceTypeElasticIp                            ResourceType = "elastic-ip"
	ResourceTypeElasticGpu                           ResourceType = "elastic-gpu"
	ResourceTypeExportImageTask                      ResourceType = "export-image-task"
	ResourceTypeExportInstanceTask                   ResourceType = "export-instance-task"
	ResourceTypeFleet                                ResourceType = "fleet"
	ResourceTypeFpgaImage                            ResourceType = "fpga-image"
	ResourceTypeHostReservation                      ResourceType = "host-reservation"
	ResourceTypeImage                                ResourceType = "image"
	ResourceTypeImportImageTask                      ResourceType = "import-image-task"
	ResourceTypeImportSnapshotTask                   ResourceType = "import-snapshot-task"
	ResourceTypeInstance                             ResourceType = "instance"
	ResourceTypeInternetGateway                      ResourceType = "internet-gateway"
	ResourceTypeKeyPair                              ResourceType = "key-pair"
	ResourceTypeLaunchTemplate                       ResourceType = "launch-template"
	ResourceTypeLocalGatewayRouteTableVpcAssociation ResourceType = "local-gateway-route-table-vpc-association"
	ResourceTypeNatgateway                           ResourceType = "natgateway"
	ResourceTypeNetworkAcl                           ResourceType = "network-acl"
	ResourceTypeNetworkInterface                     ResourceType = "network-interface"
	ResourceTypePlacementGroup                       ResourceType = "placement-group"
	ResourceTypeReservedInstances                    ResourceType = "reserved-instances"
	ResourceTypeRouteTable                           ResourceType = "route-table"
	ResourceTypeSecurityGroup                        ResourceType = "security-group"
	ResourceTypeSnapshot                             ResourceType = "snapshot"
	ResourceTypeSpotFleetRequest                     ResourceType = "spot-fleet-request"
	ResourceTypeSpotInstancesRequest                 ResourceType = "spot-instances-request"
	ResourceTypeSubnet                               ResourceType = "subnet"
	ResourceTypeTrafficMirrorFilter                  ResourceType = "traffic-mirror-filter"
	ResourceTypeTrafficMirrorSession                 ResourceType = "traffic-mirror-session"
	ResourceTypeTrafficMirrorTarget                  ResourceType = "traffic-mirror-target"
	ResourceTypeTransitGateway                       ResourceType = "transit-gateway"
	ResourceTypeTransitGatewayAttachment             ResourceType = "transit-gateway-attachment"
	ResourceTypeTransitGatewayMulticastDomain        ResourceType = "transit-gateway-multicast-domain"
	ResourceTypeTransitGatewayRouteTable             ResourceType = "transit-gateway-route-table"
	ResourceTypeVolume                               ResourceType = "volume"
	ResourceTypeVpc                                  ResourceType = "vpc"
	ResourceTypeVpcPeeringConnection                 ResourceType = "vpc-peering-connection"
	ResourceTypeVpnConnection                        ResourceType = "vpn-connection"
	ResourceTypeVpnGateway                           ResourceType = "vpn-gateway"
	ResourceTypeVpcFlowLog                           ResourceType = "vpc-flow-log"
)

Enum values for ResourceType

type ResponseError 

type ResponseError struct {
	// The error code.
	Code LaunchTemplateErrorCode
	// The error message, if applicable.
	Message *string
}

Describes the error that's returned when you cannot delete a launch template version.

type ResponseLaunchTemplateData 

type ResponseLaunchTemplateData struct {
	// The user data for the instance.
	UserData *string
	// Information about the Capacity Reservation targeting option.
	CapacityReservationSpecification *LaunchTemplateCapacityReservationSpecificationResponse
	// The security group IDs.
	SecurityGroupIds []*string
	// Indicates whether an instance stops or terminates when you initiate shutdown
	// from the instance (using the operating system command for system shutdown).
	InstanceInitiatedShutdownBehavior ShutdownBehavior
	// Indicates whether an instance is configured for hibernation. For more
	// information, see Hibernate Your Instance
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html) in the
	// Amazon Elastic Compute Cloud User Guide.
	HibernationOptions *LaunchTemplateHibernationOptions
	// The ID of the kernel, if applicable.
	KernelId *string
	// The ID of the RAM disk, if applicable.
	RamDiskId *string
	// If set to true, indicates that the instance cannot be terminated using the
	// Amazon EC2 console, command line tool, or API.
	DisableApiTermination *bool
	// The market (purchasing) option for the instances.
	InstanceMarketOptions *LaunchTemplateInstanceMarketOptions
	// The metadata options for the instance. For more information, see Instance
	// Metadata and User Data
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html)
	// in the Amazon Elastic Compute Cloud User Guide.
	MetadataOptions *LaunchTemplateInstanceMetadataOptions
	// The placement of the instance.
	Placement *LaunchTemplatePlacement
	// The network interfaces.
	NetworkInterfaces []*LaunchTemplateInstanceNetworkInterfaceSpecification
	// The security group names.
	SecurityGroups []*string
	// The monitoring for the instance.
	Monitoring *LaunchTemplatesMonitoring
	// The ID of the AMI that was used to launch the instance.
	ImageId *string
	// The tags.
	TagSpecifications []*LaunchTemplateTagSpecification
	// The license configurations.
	LicenseSpecifications []*LaunchTemplateLicenseConfiguration
	// Indicates whether the instance is optimized for Amazon EBS I/O.
	EbsOptimized *bool
	// The instance type.
	InstanceType InstanceType
	// The credit option for CPU usage of the instance.
	CreditSpecification *CreditSpecification
	// The name of the key pair.
	KeyName *string
	// The block device mappings.
	BlockDeviceMappings []*LaunchTemplateBlockDeviceMapping
	// The elastic inference accelerator for the instance.
	ElasticInferenceAccelerators []*LaunchTemplateElasticInferenceAcceleratorResponse
	// The IAM instance profile.
	IamInstanceProfile *LaunchTemplateIamInstanceProfileSpecification
	// The elastic GPU specification.
	ElasticGpuSpecifications []*ElasticGpuSpecificationResponse
	// The CPU options for the instance. For more information, see Optimizing CPU
	// Options
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-optimize-cpu.html)
	// in the Amazon Elastic Compute Cloud User Guide.
	CpuOptions *LaunchTemplateCpuOptions
}

The information for a launch template.

type RootDeviceType 

type RootDeviceType string
const (
	RootDeviceTypeEbs           RootDeviceType = "ebs"
	RootDeviceTypeInstanceStore RootDeviceType = "instance-store"
)

Enum values for RootDeviceType

type Route 

type Route struct {
	// The ID of the local gateway.
	LocalGatewayId *string
	// The IPv6 CIDR block used for the destination match.
	DestinationIpv6CidrBlock *string
	// The state of the route. The blackhole state indicates that the route's target
	// isn't available (for example, the specified gateway isn't attached to the VPC,
	// or the specified NAT instance has been terminated).
	State RouteState
	// The ID of a transit gateway.
	TransitGatewayId *string
	// The ID of the egress-only internet gateway.
	EgressOnlyInternetGatewayId *string
	// Describes how the route was created.
	//
	//     * 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 RouteOrigin
	// The IPv4 CIDR block used for the destination match.
	DestinationCidrBlock *string
	// The ID of a gateway attached to your VPC.
	GatewayId *string
	// The ID of a VPC peering connection.
	VpcPeeringConnectionId *string
	// The AWS account ID of the owner of the instance.
	InstanceOwnerId *string
	// The ID of the network interface.
	NetworkInterfaceId *string
	// The prefix of the AWS service.
	DestinationPrefixListId *string
	// The ID of a NAT gateway.
	NatGatewayId *string
	// The ID of a NAT instance in your VPC.
	InstanceId *string
}

Describes a route in a route table.

type RouteOrigin 

type RouteOrigin string
const (
	RouteOriginCreateroutetable          RouteOrigin = "CreateRouteTable"
	RouteOriginCreateroute               RouteOrigin = "CreateRoute"
	RouteOriginEnablevgwroutepropagation RouteOrigin = "EnableVgwRoutePropagation"
)

Enum values for RouteOrigin

type RouteState 

type RouteState string
const (
	RouteStateActive    RouteState = "active"
	RouteStateBlackhole RouteState = "blackhole"
)

Enum values for RouteState

type RouteTable 

type RouteTable struct {
	// The ID of the VPC.
	VpcId *string
	// The ID of the route table.
	RouteTableId *string
	// The associations between the route table and one or more subnets or a gateway.
	Associations []*RouteTableAssociation
	// The routes in the route table.
	Routes []*Route
	// Any tags assigned to the route table.
	Tags []*Tag
	// Any virtual private gateway (VGW) propagating routes.
	PropagatingVgws []*PropagatingVgw
	// The ID of the AWS account that owns the route table.
	OwnerId *string
}

Describes a route table.

type RouteTableAssociation 

type RouteTableAssociation struct {
	// The state of the association.
	AssociationState *RouteTableAssociationState
	// The ID of the subnet. A subnet ID is not returned for an implicit association.
	SubnetId *string
	// Indicates whether this is the main route table.
	Main *bool
	// The ID of the internet gateway or virtual private gateway.
	GatewayId *string
	// The ID of the route table.
	RouteTableId *string
	// The ID of the association.
	RouteTableAssociationId *string
}

Describes an association between a route table and a subnet or gateway.

type RouteTableAssociationState 

type RouteTableAssociationState struct {
	// The status message, if applicable.
	StatusMessage *string
	// The state of the association.
	State RouteTableAssociationStateCode
}

Describes the state of an association between a route table and a subnet or gateway.

type RouteTableAssociationStateCode 

type RouteTableAssociationStateCode string
const (
	RouteTableAssociationStateCodeAssociating    RouteTableAssociationStateCode = "associating"
	RouteTableAssociationStateCodeAssociated     RouteTableAssociationStateCode = "associated"
	RouteTableAssociationStateCodeDisassociating RouteTableAssociationStateCode = "disassociating"
	RouteTableAssociationStateCodeDisassociated  RouteTableAssociationStateCode = "disassociated"
	RouteTableAssociationStateCodeFailed         RouteTableAssociationStateCode = "failed"
)

Enum values for RouteTableAssociationStateCode

type RuleAction 

type RuleAction string
const (
	RuleActionAllow RuleAction = "allow"
	RuleActionDeny  RuleAction = "deny"
)

Enum values for RuleAction

type RunInstancesMonitoringEnabled 

type RunInstancesMonitoringEnabled struct {
	// Indicates whether detailed monitoring is enabled. Otherwise, basic monitoring is
	// enabled.
	Enabled *bool
}

Describes the monitoring of an instance.

type S3Storage 

type S3Storage struct {
	// The beginning of the file name of the AMI.
	Prefix *string
	// The signature of the JSON document.
	UploadPolicySignature *string
	// An Amazon S3 upload policy that gives Amazon EC2 permission to upload items into
	// Amazon S3 on your behalf.
	UploadPolicy []byte
	// The bucket in which to store the AMI. You can specify a bucket that you already
	// own or a new bucket that Amazon EC2 creates on your behalf. If you specify a
	// bucket that belongs to someone else, Amazon EC2 returns an error.
	Bucket *string
	// The access key ID of the owner of the bucket. Before you specify a value for
	// your access key ID, review and follow the guidance in Best Practices for
	// Managing AWS Access Keys
	// (https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html).
	AWSAccessKeyId *string
}

Describes the storage parameters for S3 and S3 buckets for an instance store-backed AMI.

type ScheduledInstance 

type ScheduledInstance struct {
	// The number of instances.
	InstanceCount *int32
	// The total number of hours for a single instance for the entire term.
	TotalScheduledInstanceHours *int32
	// The start date for the Scheduled Instance.
	TermStartDate *time.Time
	// The instance type.
	InstanceType *string
	// The end date for the Scheduled Instance.
	TermEndDate *time.Time
	// The network platform (EC2-Classic or EC2-VPC).
	NetworkPlatform *string
	// The number of hours in the schedule.
	SlotDurationInHours *int32
	// The time that the previous schedule ended or will end.
	PreviousSlotEndTime *time.Time
	// The platform (Linux/UNIX or Windows).
	Platform *string
	// The schedule recurrence.
	Recurrence *ScheduledInstanceRecurrence
	// The Availability Zone.
	AvailabilityZone *string
	// The Scheduled Instance ID.
	ScheduledInstanceId *string
	// The date when the Scheduled Instance was purchased.
	CreateDate *time.Time
	// The time for the next schedule to start.
	NextSlotStartTime *time.Time
	// The hourly price for a single instance.
	HourlyPrice *string
}

Describes a Scheduled Instance.

type ScheduledInstanceAvailability 

type ScheduledInstanceAvailability struct {
	// The Availability Zone.
	AvailabilityZone *string
	// The minimum term. The only possible value is 365 days.
	MinTermDurationInDays *int32
	// The number of hours in the schedule.
	SlotDurationInHours *int32
	// The purchase token. This token expires in two hours.
	PurchaseToken *string
	// The maximum term. The only possible value is 365 days.
	MaxTermDurationInDays *int32
	// The platform (Linux/UNIX or Windows).
	Platform *string
	// The number of available instances.
	AvailableInstanceCount *int32
	// The network platform (EC2-Classic or EC2-VPC).
	NetworkPlatform *string
	// The total number of hours for a single instance for the entire term.
	TotalScheduledInstanceHours *int32
	// The time period for the first schedule to start.
	FirstSlotStartTime *time.Time
	// The schedule recurrence.
	Recurrence *ScheduledInstanceRecurrence
	// The hourly price for a single instance.
	HourlyPrice *string
	// The instance type. You can specify one of the C3, C4, M4, or R3 instance types.
	InstanceType *string
}

Describes a schedule that is available for your Scheduled Instances.

type ScheduledInstanceRecurrence 

type ScheduledInstanceRecurrence struct {
	// The frequency (Daily, Weekly, or Monthly).
	Frequency *string
	// The unit for occurrenceDaySet (DayOfWeek or DayOfMonth).
	OccurrenceUnit *string
	// Indicates whether the occurrence is relative to the end of the specified week or
	// month.
	OccurrenceRelativeToEnd *bool
	// The days. For a monthly schedule, this is one or more days of the month (1-31).
	// For a weekly schedule, this is one or more days of the week (1-7, where 1 is
	// Sunday).
	OccurrenceDaySet []*int32
	// The interval quantity. The interval unit depends on the value of frequency. For
	// example, every 2 weeks or every 2 months.
	Interval *int32
}

Describes the recurring schedule for a Scheduled Instance.

type ScheduledInstanceRecurrenceRequest 

type ScheduledInstanceRecurrenceRequest struct {
	// The interval quantity. The interval unit depends on the value of Frequency. For
	// example, every 2 weeks or every 2 months.
	Interval *int32
	// The days. For a monthly schedule, this is one or more days of the month (1-31).
	// For a weekly schedule, this is one or more days of the week (1-7, where 1 is
	// Sunday). You can't specify this value with a daily schedule. If the occurrence
	// is relative to the end of the month, you can specify only a single day.
	OccurrenceDays []*int32
	// The frequency (Daily, Weekly, or Monthly).
	Frequency *string
	// The unit for OccurrenceDays (DayOfWeek or DayOfMonth). This value is required
	// for a monthly schedule. You can't specify DayOfWeek with a weekly schedule. You
	// can't specify this value with a daily schedule.
	OccurrenceUnit *string
	// Indicates whether the occurrence is relative to the end of the specified week or
	// month. You can't specify this value with a daily schedule.
	OccurrenceRelativeToEnd *bool
}

Describes the recurring schedule for a Scheduled Instance.

type ScheduledInstancesBlockDeviceMapping 

type ScheduledInstancesBlockDeviceMapping struct {
	// Parameters used to set up EBS volumes automatically when the instance is
	// launched.
	Ebs *ScheduledInstancesEbs
	// The device name (for example, /dev/sdh or xvdh).
	DeviceName *string
	// The virtual device name (ephemeralN). Instance store volumes are numbered
	// starting from 0. An instance type with two 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. 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
	// Suppresses the specified device included in the block device mapping of the AMI.
	NoDevice *string
}

Describes a block device mapping for a Scheduled Instance.

type ScheduledInstancesEbs 

type ScheduledInstancesEbs struct {
	// Indicates whether the volume is encrypted. You can attached encrypted volumes
	// only to instances that support them.
	Encrypted *bool
	// The size of the volume, in GiB. Default: If you're creating the volume from a
	// snapshot and don't specify a volume size, the default is the snapshot size.
	VolumeSize *int32
	// Indicates whether the volume is deleted on instance termination.
	DeleteOnTermination *bool
	// The number of I/O operations per second (IOPS) that the volume supports. For io1
	// 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. For more
	// information about gp2 baseline performance, I/O credits, and bursting, see
	// Amazon EBS Volume Types
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html) in the
	// Amazon Elastic Compute Cloud User Guide. Constraint: Range is 100-20000 IOPS for
	// io1 volumes and 100-10000 IOPS for gp2 volumes. Condition: This parameter is
	// required for requests to create io1volumes; it is not used in requests to create
	// gp2, st1, sc1, or standard volumes.
	Iops *int32
	// The volume type. gp2 for General Purpose SSD, io1 for Provisioned IOPS SSD,
	// Throughput Optimized HDD for st1, Cold HDD for sc1, or standard for Magnetic.
	// Default: gp2
	VolumeType *string
	// The ID of the snapshot.
	SnapshotId *string
}

Describes an EBS volume for a Scheduled Instance.

type ScheduledInstancesIamInstanceProfile 

type ScheduledInstancesIamInstanceProfile struct {
	// The Amazon Resource Name (ARN).
	Arn *string
	// The name.
	Name *string
}

Describes an IAM instance profile for a Scheduled Instance.

type ScheduledInstancesIpv6Address 

type ScheduledInstancesIpv6Address struct {
	// The IPv6 address.
	Ipv6Address *string
}

Describes an IPv6 address.

type ScheduledInstancesLaunchSpecification 

type ScheduledInstancesLaunchSpecification struct {
	// Indicates whether the instances are optimized for EBS I/O. This optimization
	// provides dedicated throughput to Amazon EBS and an optimized configuration stack
	// to provide optimal EBS I/O performance. This optimization isn't available with
	// all instance types. Additional usage charges apply when using an EBS-optimized
	// instance. Default: false
	EbsOptimized *bool
	// Enable or disable monitoring for the instances.
	Monitoring *ScheduledInstancesMonitoring
	// The ID of the RAM disk.
	RamdiskId *string
	// The placement information.
	Placement *ScheduledInstancesPlacement
	// The IAM instance profile.
	IamInstanceProfile *ScheduledInstancesIamInstanceProfile
	// The instance type.
	InstanceType *string
	// The IDs of the security groups.
	SecurityGroupIds []*string
	// The ID of the kernel.
	KernelId *string
	// The ID of the subnet in which to launch the instances.
	SubnetId *string
	// The block device mapping entries.
	BlockDeviceMappings []*ScheduledInstancesBlockDeviceMapping
	// The network interfaces.
	NetworkInterfaces []*ScheduledInstancesNetworkInterface
	// The name of the key pair.
	KeyName *string
	// The ID of the Amazon Machine Image (AMI).
	ImageId *string
	// The base64-encoded MIME user data.
	UserData *string
}

Describes the launch specification for a Scheduled Instance. If you are launching the Scheduled Instance in EC2-VPC, you must specify the ID of the subnet. You can specify the subnet using either SubnetId or NetworkInterface.

type ScheduledInstancesMonitoring 

type ScheduledInstancesMonitoring struct {
	// Indicates whether monitoring is enabled.
	Enabled *bool
}

Describes whether monitoring is enabled for a Scheduled Instance.

type ScheduledInstancesNetworkInterface 

type ScheduledInstancesNetworkInterface struct {
	// The IDs of the security groups.
	Groups []*string
	// The IPv4 address of the network interface within the subnet.
	PrivateIpAddress *string
	// The index of the device for the network interface attachment.
	DeviceIndex *int32
	// The private IPv4 addresses.
	PrivateIpAddressConfigs []*ScheduledInstancesPrivateIpAddressConfig
	// Indicates whether to delete the interface when the instance is terminated.
	DeleteOnTermination *bool
	// Indicates whether to assign a public IPv4 address to instances launched in a
	// VPC. The public IPv4 address can only be assigned to a network interface for
	// eth0, and can only be assigned to a new network interface, not an existing one.
	// You cannot specify more than one network interface in the request. If launching
	// into a default subnet, the default value is true.
	AssociatePublicIpAddress *bool
	// The ID of the network interface.
	NetworkInterfaceId *string
	// The specific IPv6 addresses from the subnet range.
	Ipv6Addresses []*ScheduledInstancesIpv6Address
	// The ID of the subnet.
	SubnetId *string
	// The description.
	Description *string
	// The number of IPv6 addresses to assign to the network interface. The IPv6
	// addresses are automatically selected from the subnet range.
	Ipv6AddressCount *int32
	// The number of secondary private IPv4 addresses.
	SecondaryPrivateIpAddressCount *int32
}

Describes a network interface for a Scheduled Instance.

type ScheduledInstancesPlacement 

type ScheduledInstancesPlacement struct {
	// The Availability Zone.
	AvailabilityZone *string
	// The name of the placement group.
	GroupName *string
}

Describes the placement for a Scheduled Instance.

type ScheduledInstancesPrivateIpAddressConfig 

type ScheduledInstancesPrivateIpAddressConfig struct {
	// The IPv4 address.
	PrivateIpAddress *string
	// Indicates whether this is a primary IPv4 address. Otherwise, this is a secondary
	// IPv4 address.
	Primary *bool
}

Describes a private IPv4 address for a Scheduled Instance.

type Scope 

type Scope string
const (
	ScopeAvailability_zone Scope = "Availability Zone"
	ScopeRegional          Scope = "Region"
)

Enum values for Scope

type SecurityGroup 

type SecurityGroup struct {
	// [VPC only] The outbound rules associated with the security group.
	IpPermissionsEgress []*IpPermission
	// The name of the security group.
	GroupName *string
	// [VPC only] The ID of the VPC for the security group.
	VpcId *string
	// Any tags assigned to the security group.
	Tags []*Tag
	// The ID of the security group.
	GroupId *string
	// The inbound rules associated with the security group.
	IpPermissions []*IpPermission
	// The AWS account ID of the owner of the security group.
	OwnerId *string
	// A description of the security group.
	Description *string
}

Describes a security group

type SecurityGroupIdentifier 

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

Describes a security group.

type SecurityGroupReference 

type SecurityGroupReference struct {
	// The ID of your security group.
	GroupId *string
	// The ID of the VPC with the referencing security group.
	ReferencingVpcId *string
	// The ID of the VPC peering connection.
	VpcPeeringConnectionId *string
}

Describes a VPC with a security group that references your security group.

type ServiceConfiguration 

type ServiceConfiguration struct {
	// Indicates whether the service manages its VPC endpoints. Management of the
	// service VPC endpoints using the VPC endpoint API is restricted.
	ManagesVpcEndpoints *bool
	// The private DNS name for the service.
	PrivateDnsName *string
	// The DNS names for the service.
	BaseEndpointDnsNames []*string
	// The ID of the service.
	ServiceId *string
	// The type of service.
	ServiceType []*ServiceTypeDetail
	// Any tags assigned to the service.
	Tags []*Tag
	// The name of the service.
	ServiceName *string
	// Information about the endpoint service private DNS name configuration.
	PrivateDnsNameConfiguration *PrivateDnsNameConfiguration
	// The service state.
	ServiceState ServiceState
	// The Availability Zones in which the service is available.
	AvailabilityZones []*string
	// The Amazon Resource Names (ARNs) of the Network Load Balancers for the service.
	NetworkLoadBalancerArns []*string
	// Indicates whether requests from other AWS accounts to create an endpoint to the
	// service must first be accepted.
	AcceptanceRequired *bool
}

Describes a service configuration for a VPC endpoint service.

type ServiceDetail 

type ServiceDetail struct {
	// Indicates whether the service supports endpoint policies.
	VpcEndpointPolicySupported *bool
	// The DNS names for the service.
	BaseEndpointDnsNames []*string
	// Indicates whether the service manages its VPC endpoints. Management of the
	// service VPC endpoints using the VPC endpoint API is restricted.
	ManagesVpcEndpoints *bool
	// The type of service.
	ServiceType []*ServiceTypeDetail
	// The verification state of the VPC endpoint service. Consumers of the endpoint
	// service cannot use the private name when the state is not verified.
	PrivateDnsNameVerificationState DnsNameState
	// The Amazon Resource Name (ARN) of the service.
	ServiceName *string
	// Any tags assigned to the service.
	Tags []*Tag
	// The Availability Zones in which the service is available.
	AvailabilityZones []*string
	// The ID of the endpoint service.
	ServiceId *string
	// Indicates whether VPC endpoint connection requests to the service must be
	// accepted by the service owner.
	AcceptanceRequired *bool
	// The private DNS name for the service.
	PrivateDnsName *string
	// The AWS account ID of the service owner.
	Owner *string
}

Describes a VPC endpoint service.

type ServiceState 

type ServiceState string
const (
	ServiceStatePending   ServiceState = "Pending"
	ServiceStateAvailable ServiceState = "Available"
	ServiceStateDeleting  ServiceState = "Deleting"
	ServiceStateDeleted   ServiceState = "Deleted"
	ServiceStateFailed    ServiceState = "Failed"
)

Enum values for ServiceState

type ServiceType 

type ServiceType string
const (
	ServiceTypeInterface ServiceType = "Interface"
	ServiceTypeGateway   ServiceType = "Gateway"
)

Enum values for ServiceType

type ServiceTypeDetail 

type ServiceTypeDetail struct {
	// The type of service.
	ServiceType ServiceType
}

Describes the type of service for a VPC endpoint.

type ShutdownBehavior 

type ShutdownBehavior string
const (
	ShutdownBehaviorStop      ShutdownBehavior = "stop"
	ShutdownBehaviorTerminate ShutdownBehavior = "terminate"
)

Enum values for ShutdownBehavior

type SlotDateTimeRangeRequest 

type SlotDateTimeRangeRequest struct {
	// The earliest date and time, in UTC, for the Scheduled Instance to start.
	EarliestTime *time.Time
	// The latest date and time, in UTC, for the Scheduled Instance to start. This
	// value must be later than or equal to the earliest date and at most three months
	// in the future.
	LatestTime *time.Time
}

Describes the time period for a Scheduled Instance to start its first schedule. The time period must span less than one day.

type SlotStartTimeRangeRequest 

type SlotStartTimeRangeRequest struct {
	// The earliest date and time, in UTC, for the Scheduled Instance to start.
	EarliestTime *time.Time
	// The latest date and time, in UTC, for the Scheduled Instance to start.
	LatestTime *time.Time
}

Describes the time period for a Scheduled Instance to start its first schedule.

type Snapshot 

type Snapshot struct {
	// The AWS account ID of the EBS snapshot owner.
	OwnerId *string
	// The size of the volume, in GiB.
	VolumeSize *int32
	// The AWS owner alias, as maintained by Amazon. The possible values are: amazon |
	// self | all | aws-marketplace | microsoft. This AWS owner alias is not to be
	// confused with the user-configured AWS account alias, which is set from the IAM
	// console.
	OwnerAlias *string
	// The ID of the snapshot. Each snapshot receives a unique identifier when it is
	// created.
	SnapshotId *string
	// The ID of the volume that was used to create the snapshot. Snapshots created by
	// the CopySnapshot () action have an arbitrary volume ID that should not be used
	// for any purpose.
	VolumeId *string
	// Encrypted Amazon EBS snapshots are copied asynchronously. If a snapshot copy
	// operation fails (for example, if the proper AWS Key Management Service (AWS KMS)
	// permissions are not obtained) this field displays error state details to help
	// you diagnose why the error occurred. This parameter is only returned by
	// DescribeSnapshots ().
	StateMessage *string
	// Indicates whether the snapshot is encrypted.
	Encrypted *bool
	// Any tags assigned to the snapshot.
	Tags []*Tag
	// The data encryption key identifier for the snapshot. This value is a unique
	// identifier that corresponds to the data encryption key that was used to encrypt
	// the original volume or snapshot copy. Because data encryption keys are inherited
	// by volumes created from snapshots, and vice versa, if snapshots share the same
	// data encryption key identifier, then they belong to the same volume/snapshot
	// lineage. This parameter is only returned by DescribeSnapshots ().
	DataEncryptionKeyId *string
	// The progress of the snapshot, as a percentage.
	Progress *string
	// The Amazon Resource Name (ARN) of the AWS Key Management Service (AWS KMS)
	// customer master key (CMK) that was used to protect the volume encryption key for
	// the parent volume.
	KmsKeyId *string
	// The description for the snapshot.
	Description *string
	// The snapshot state.
	State SnapshotState
	// The time stamp when the snapshot was initiated.
	StartTime *time.Time
}

Describes a snapshot.

type SnapshotAttributeName 

type SnapshotAttributeName string
const (
	SnapshotAttributeNameProductcodes           SnapshotAttributeName = "productCodes"
	SnapshotAttributeNameCreatevolumepermission SnapshotAttributeName = "createVolumePermission"
)

Enum values for SnapshotAttributeName

type SnapshotDetail 

type SnapshotDetail struct {
	// The snapshot ID of the disk being imported.
	SnapshotId *string
	// The block device mapping for the snapshot.
	DeviceName *string
	// A brief status of the snapshot creation.
	Status *string
	// The URL used to access the disk image.
	Url *string
	// The Amazon S3 bucket for the disk image.
	UserBucket *UserBucketDetails
	// The percentage of progress for the task.
	Progress *string
	// A detailed status message for the snapshot creation.
	StatusMessage *string
	// A description for the snapshot.
	Description *string
	// The size of the disk in the snapshot, in GiB.
	DiskImageSize *float64
	// The format of the disk image from which the snapshot is created.
	Format *string
}

Describes the snapshot created from the imported disk.

type SnapshotDiskContainer 

type SnapshotDiskContainer struct {
	// The description of the disk image being imported.
	Description *string
	// The Amazon S3 bucket for the disk image.
	UserBucket *UserBucket
	// The URL to the Amazon S3-based disk image being imported. It can either be a
	// https URL (https://..) or an Amazon S3 URL (s3://..).
	Url *string
	// The format of the disk image being imported. Valid values: VHD | VMDK
	Format *string
}

The disk container object for the import snapshot request.

type SnapshotInfo 

type SnapshotInfo struct {
	// Description specified by the CreateSnapshotRequest that has been applied to all
	// snapshots.
	Description *string
	// Indicates whether the snapshot is encrypted.
	Encrypted *bool
	// Source volume from which this snapshot was created.
	VolumeId *string
	// Snapshot id that can be used to describe this snapshot.
	SnapshotId *string
	// Current state of the snapshot.
	State SnapshotState
	// Progress this snapshot has made towards completing.
	Progress *string
	// Account id used when creating this snapshot.
	OwnerId *string
	// Size of the volume from which this snapshot was created.
	VolumeSize *int32
	// Tags associated with this snapshot.
	Tags []*Tag
	// Time this snapshot was started. This is the same for all snapshots initiated by
	// the same request.
	StartTime *time.Time
}

Information about a snapshot.

type SnapshotState 

type SnapshotState string
const (
	SnapshotStatePending   SnapshotState = "pending"
	SnapshotStateCompleted SnapshotState = "completed"
	SnapshotStateError     SnapshotState = "error"
)

Enum values for SnapshotState

type SnapshotTaskDetail 

type SnapshotTaskDetail struct {
	// The snapshot ID of the disk being imported.
	SnapshotId *string
	// A brief status for the import snapshot task.
	Status *string
	// Indicates whether the snapshot is encrypted.
	Encrypted *bool
	// The description of the snapshot.
	Description *string
	// The URL of the disk image from which the snapshot is created.
	Url *string
	// The percentage of completion for the import snapshot task.
	Progress *string
	// The size of the disk in the snapshot, in GiB.
	DiskImageSize *float64
	// A detailed status message for the import snapshot task.
	StatusMessage *string
	// The Amazon S3 bucket for the disk image.
	UserBucket *UserBucketDetails
	// The format of the disk image from which the snapshot is created.
	Format *string
	// The identifier for the AWS Key Management Service (AWS KMS) customer master key
	// (CMK) that was used to create the encrypted snapshot.
	KmsKeyId *string
}

Details about the import snapshot task.

type SpotAllocationStrategy 

type SpotAllocationStrategy string
const (
	SpotAllocationStrategyLowest_price       SpotAllocationStrategy = "lowest-price"
	SpotAllocationStrategyDiversified        SpotAllocationStrategy = "diversified"
	SpotAllocationStrategyCapacity_optimized SpotAllocationStrategy = "capacity-optimized"
)

Enum values for SpotAllocationStrategy

type SpotDatafeedSubscription 

type SpotDatafeedSubscription struct {
	// The prefix that is prepended to data feed files.
	Prefix *string
	// The AWS account ID of the account.
	OwnerId *string
	// The fault codes for the Spot Instance request, if any.
	Fault *SpotInstanceStateFault
	// The state of the Spot Instance data feed subscription.
	State DatafeedSubscriptionState
	// The Amazon S3 bucket where the Spot Instance data feed is located.
	Bucket *string
}

Describes the data feed for a Spot Instance.

type SpotFleetLaunchSpecification 

type SpotFleetLaunchSpecification struct {
	// One or more block devices that are mapped to the Spot Instances. You can't
	// specify both a snapshot ID and an encryption value. This is because only blank
	// volumes can be encrypted on creation. If a snapshot is the basis for a volume,
	// it is not blank and its encryption status is used for the volume encryption
	// status.
	BlockDeviceMappings []*BlockDeviceMapping
	// One or more security groups. When requesting instances in a VPC, you must
	// specify the IDs of the security groups. When requesting instances in
	// EC2-Classic, you can specify the names or the IDs of the security groups.
	SecurityGroups []*GroupIdentifier
	// Indicates whether the instances are optimized for EBS I/O. This optimization
	// provides dedicated throughput to Amazon EBS and an optimized configuration stack
	// to provide optimal EBS I/O performance. This optimization isn't available with
	// all instance types. Additional usage charges apply when using an EBS Optimized
	// instance. Default: false
	EbsOptimized *bool
	// One or more network interfaces. If you specify a network interface, you must
	// specify subnet IDs and security group IDs using the network interface.
	NetworkInterfaces []*InstanceNetworkInterfaceSpecification
	// The name of the key pair.
	KeyName *string
	// The placement information.
	Placement *SpotPlacement
	// The instance type.
	InstanceType InstanceType
	// Enable or disable monitoring for the instances.
	Monitoring *SpotFleetMonitoring
	// The maximum price per unit hour that you are willing to pay for a Spot Instance.
	// If this value is not specified, the default is the Spot price specified for the
	// fleet. To determine the Spot price per unit hour, divide the Spot price by the
	// value of WeightedCapacity.
	SpotPrice *string
	// The tags to apply during creation.
	TagSpecifications []*SpotFleetTagSpecification
	// The ID of the RAM disk. Some kernels require additional drivers at launch. Check
	// the kernel requirements for information about whether you need to specify a RAM
	// disk. To find kernel requirements, refer to the AWS Resource Center and search
	// for the kernel ID.
	RamdiskId *string
	// The Base64-encoded user data that instances use when starting up.
	UserData *string
	// The ID of the AMI.
	ImageId *string
	// The number of units provided by the specified instance type. These are the same
	// units that you chose to set the target capacity in terms of instances, or a
	// performance characteristic such as vCPUs, memory, or I/O. If the target capacity
	// divided by this value is not a whole number, Amazon EC2 rounds the number of
	// instances to the next whole number. If this value is not specified, the default
	// is 1.
	WeightedCapacity *float64
	// The IAM instance profile.
	IamInstanceProfile *IamInstanceProfileSpecification
	// The IDs of the subnets in which to launch the instances. To specify multiple
	// subnets, separate them using commas; for example, "subnet-1234abcdeexample1,
	// subnet-0987cdef6example2".
	SubnetId *string
	// Deprecated.
	AddressingType *string
	// The ID of the kernel.
	KernelId *string
}

Describes the launch specification for one or more Spot Instances. If you include On-Demand capacity in your fleet request, you can't use SpotFleetLaunchSpecification; you must use LaunchTemplateConfig (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_LaunchTemplateConfig.html).

type SpotFleetMonitoring 

type SpotFleetMonitoring struct {
	// Enables monitoring for the instance. Default: false
	Enabled *bool
}

Describes whether monitoring is enabled.

type SpotFleetRequestConfig 

type SpotFleetRequestConfig struct {
	// The ID of the Spot Fleet request.
	SpotFleetRequestId *string
	// The state of the Spot Fleet request.
	SpotFleetRequestState BatchState
	// The progress of the Spot Fleet request. If there is an error, the status is
	// error. After all requests are placed, the status is pending_fulfillment. If the
	// size of the fleet is equal to or greater than its target capacity, the status is
	// fulfilled. If the size of the fleet is decreased, the status is
	// pending_termination while Spot Instances are terminating.
	ActivityStatus ActivityStatus
	// The creation date and time of the request.
	CreateTime *time.Time
	// The configuration of the Spot Fleet request.
	SpotFleetRequestConfig *SpotFleetRequestConfigData
	// The tags for a Spot Fleet resource.
	Tags []*Tag
}

Describes a Spot Fleet request.

type SpotFleetRequestConfigData 

type SpotFleetRequestConfigData struct {
	// The key-value pair for tagging the Spot Fleet request on creation. The value for
	// ResourceType must be spot-fleet-request, otherwise the Spot Fleet request fails.
	// To tag instances at launch, specify the tags in the launch template
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template)
	// (valid only if you use LaunchTemplateConfigs) or in the
	// SpotFleetTagSpecification
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetTagSpecification.html)
	// (valid only if you use LaunchSpecifications). For information about tagging
	// after launch, see Tagging Your Resources
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-resources).
	TagSpecifications []*TagSpecification
	// The number of units to request for the Spot Fleet. 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.
	TargetCapacity *int32
	// The start date and time of the request, in UTC format (YYYY-MM-DDTHH:MM:SSZ). By
	// default, Amazon EC2 starts fulfilling the request immediately.
	ValidFrom *time.Time
	// The behavior when a Spot Instance is interrupted. The default is terminate.
	InstanceInterruptionBehavior InstanceInterruptionBehavior
	// The launch template and overrides. If you specify LaunchTemplateConfigs, you
	// can't specify LaunchSpecifications. If you include On-Demand capacity in your
	// request, you must use LaunchTemplateConfigs.
	LaunchTemplateConfigs []*LaunchTemplateConfig
	// Indicates how to allocate the target Spot Instance capacity across the Spot
	// Instance pools specified by the Spot Fleet request. If the allocation strategy
	// is lowestPrice, Spot Fleet launches instances from the Spot Instance pools with
	// the lowest price. This is the default allocation strategy. If the allocation
	// strategy is diversified, Spot Fleet launches instances from all the Spot
	// Instance pools that you specify. If the allocation strategy is
	// capacityOptimized, Spot Fleet launches instances from Spot Instance pools with
	// optimal capacity for the number of instances that are launching.
	AllocationStrategy AllocationStrategy
	// The number of units fulfilled by this request compared to the set target
	// capacity. You cannot set this value.
	FulfilledCapacity *float64
	// The maximum price per unit hour that you are willing to pay for a Spot Instance.
	// The default is the On-Demand price.
	SpotPrice *string
	// Indicates whether Spot Fleet should replace unhealthy instances.
	ReplaceUnhealthyInstances *bool
	// The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM)
	// role that grants the Spot Fleet the permission to request, launch, terminate,
	// and tag instances on your behalf. For more information, see Spot Fleet
	// prerequisites
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-requests.html#spot-fleet-prerequisites)
	// in the Amazon EC2 User Guide for Linux Instances. Spot Fleet can terminate Spot
	// Instances on your behalf when you cancel its Spot Fleet request using
	// CancelSpotFleetRequests
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CancelSpotFleetRequests)
	// or when the Spot Fleet request expires, if you set
	// TerminateInstancesWithExpiration.
	IamFleetRole *string
	// The maximum amount per hour for Spot Instances that you're willing to pay. You
	// can use the spotdMaxTotalPrice parameter, the onDemandMaxTotalPrice parameter,
	// or both parameters to ensure that your fleet cost does not exceed your budget.
	// If you set a maximum price per hour for the On-Demand Instances and Spot
	// Instances in your request, Spot Fleet will launch instances until it reaches the
	// maximum amount you're willing to pay. When the maximum amount you're willing to
	// pay is reached, the fleet stops launching instances even if it hasn’t met the
	// target capacity.
	SpotMaxTotalPrice *string
	// The number of Spot pools across which to allocate your target Spot capacity.
	// Valid only when Spot AllocationStrategy is set to lowest-price. Spot Fleet
	// selects the cheapest Spot pools and evenly allocates your target Spot capacity
	// across the number of Spot pools that you specify.
	InstancePoolsToUseCount *int32
	// One or more Classic Load Balancers and target groups to attach to the Spot Fleet
	// request. Spot Fleet registers the running Spot Instances with the specified
	// Classic Load Balancers and target groups. With Network Load Balancers, Spot
	// Fleet cannot register instances that have the following instance types: C1, CC1,
	// CC2, CG1, CG2, CR1, CS1, G1, G2, HI1, HS1, M1, M2, M3, and T1.
	LoadBalancersConfig *LoadBalancersConfig
	// Indicates whether running Spot Instances should be terminated if you decrease
	// the target capacity of the Spot Fleet request below the current size of the Spot
	// Fleet.
	ExcessCapacityTerminationPolicy ExcessCapacityTerminationPolicy
	// The maximum amount per hour for On-Demand Instances that you're willing to pay.
	// You can use the onDemandMaxTotalPrice parameter, the spotMaxTotalPrice
	// parameter, or both parameters to ensure that your fleet cost does not exceed
	// your budget. If you set a maximum price per hour for the On-Demand Instances and
	// Spot Instances in your request, Spot Fleet will launch instances until it
	// reaches the maximum amount you're willing to pay. When the maximum amount you're
	// willing to pay is reached, the fleet stops launching instances even if it hasn’t
	// met the target capacity.
	OnDemandMaxTotalPrice *string
	// The end date and time of the request, in UTC format (YYYY-MM-DDTHH:MM:SSZ).
	// After the end date and time, no new Spot Instance requests are placed or able to
	// fulfill the request. If no value is specified, the Spot Fleet request remains
	// until you cancel it.
	ValidUntil *time.Time
	// The type of request. Indicates whether the Spot Fleet only requests the target
	// capacity or also attempts to maintain it. When this value is request, the Spot
	// Fleet only places the required requests. It does not attempt to replenish Spot
	// Instances if capacity is diminished, nor does it submit requests in alternative
	// Spot pools if capacity is not available. When this value is maintain, the Spot
	// Fleet maintains the target capacity. The Spot Fleet places the required requests
	// to meet capacity and automatically replenishes any interrupted instances.
	// Default: maintain. instant is listed but is not used by Spot Fleet.
	Type FleetType
	// The launch specifications for the Spot Fleet request. If you specify
	// LaunchSpecifications, you can't specify LaunchTemplateConfigs. If you include
	// On-Demand capacity in your request, you must use LaunchTemplateConfigs.
	LaunchSpecifications []*SpotFleetLaunchSpecification
	// The order of the launch template overrides to use in fulfilling On-Demand
	// capacity. If you specify lowestPrice, Spot Fleet uses price to determine the
	// order, launching the lowest price first. If you specify prioritized, Spot Fleet
	// uses the priority that you assign to each Spot Fleet launch template override,
	// launching the highest priority first. If you do not specify a value, Spot Fleet
	// defaults to lowestPrice.
	OnDemandAllocationStrategy OnDemandAllocationStrategy
	// The number of On-Demand units fulfilled by this request compared to the set
	// target On-Demand capacity.
	OnDemandFulfilledCapacity *float64
	// The number of On-Demand 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.
	OnDemandTargetCapacity *int32
	// A unique, case-sensitive identifier that you provide to ensure the idempotency
	// of your listings. This helps to avoid duplicate listings. For more information,
	// see Ensuring Idempotency
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html).
	ClientToken *string
	// Indicates whether running Spot Instances are terminated when the Spot Fleet
	// request expires.
	TerminateInstancesWithExpiration *bool
}

Describes the configuration of a Spot Fleet request.

type SpotFleetTagSpecification 

type SpotFleetTagSpecification struct {
	// The tags.
	Tags []*Tag
	// The type of resource. Currently, the only resource type that is supported is
	// instance. To tag the Spot Fleet request on creation, use the TagSpecifications
	// parameter in SpotFleetRequestConfigData
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetRequestConfigData.html).
	ResourceType ResourceType
}

The tags for a Spot Fleet resource.

type SpotInstanceInterruptionBehavior 

type SpotInstanceInterruptionBehavior string
const (
	SpotInstanceInterruptionBehaviorHibernate SpotInstanceInterruptionBehavior = "hibernate"
	SpotInstanceInterruptionBehaviorStop      SpotInstanceInterruptionBehavior = "stop"
	SpotInstanceInterruptionBehaviorTerminate SpotInstanceInterruptionBehavior = "terminate"
)

Enum values for SpotInstanceInterruptionBehavior

type SpotInstanceRequest 

type SpotInstanceRequest struct {
	// The fault codes for the Spot Instance request, if any.
	Fault *SpotInstanceStateFault
	// The start date of the request, in UTC format (for example,
	// YYYY-MM-DDTHH:MM:SSZ). The request becomes active at this date and time.
	ValidFrom *time.Time
	// Additional information for launching instances.
	LaunchSpecification *LaunchSpecification
	// The ID of the Spot Instance request.
	SpotInstanceRequestId *string
	// The product description associated with the Spot Instance.
	ProductDescription RIProductDescription
	// If you specified a duration and your Spot Instance request was fulfilled, this
	// is the fixed hourly price in effect for the Spot Instance while it runs.
	ActualBlockHourlyPrice *string
	// The instance launch group. Launch groups are Spot Instances that launch together
	// and terminate together.
	LaunchGroup *string
	// The behavior when a Spot Instance is interrupted.
	InstanceInterruptionBehavior InstanceInterruptionBehavior
	// The Availability Zone group. If you specify the same Availability Zone group for
	// all Spot Instance requests, all Spot Instances are launched in the same
	// Availability Zone.
	AvailabilityZoneGroup *string
	// The state of the Spot Instance request. Spot status information helps track your
	// Spot Instance requests. For more information, see Spot status
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-bid-status.html) in
	// the Amazon EC2 User Guide for Linux Instances.
	State SpotInstanceState
	// The end date of the request, in UTC format (for example, YYYY-MM-DDTHH:MM:SSZ).
	// If this is a one-time request, it remains active until all instances launch, the
	// request is canceled, or this date is reached. If the request is persistent, it
	// remains active until it is canceled or this date is reached. The default end
	// date is 7 days from the current date.
	ValidUntil *time.Time
	// Any tags assigned to the resource.
	Tags []*Tag
	// The Spot Instance request type.
	Type SpotInstanceType
	// The instance ID, if an instance has been launched to fulfill the Spot Instance
	// request.
	InstanceId *string
	// The status code and status message describing the Spot Instance request.
	Status *SpotInstanceStatus
	// The date and time when the Spot Instance request was created, in UTC format (for
	// example, YYYY-MM-DDTHH:MM:SSZ).
	CreateTime *time.Time
	// The maximum price per hour that you are willing to pay for a Spot Instance.
	SpotPrice *string
	// The Availability Zone in which the request is launched.
	LaunchedAvailabilityZone *string
	// The duration for the Spot Instance, in minutes.
	BlockDurationMinutes *int32
}

Describes a Spot Instance request.

type SpotInstanceState 

type SpotInstanceState string
const (
	SpotInstanceStateOpen      SpotInstanceState = "open"
	SpotInstanceStateActive    SpotInstanceState = "active"
	SpotInstanceStateClosed    SpotInstanceState = "closed"
	SpotInstanceStateCancelled SpotInstanceState = "cancelled"
	SpotInstanceStateFailed    SpotInstanceState = "failed"
)

Enum values for SpotInstanceState

type SpotInstanceStateFault 

type SpotInstanceStateFault struct {
	// The message for the Spot Instance state change.
	Message *string
	// The reason code for the Spot Instance state change.
	Code *string
}

Describes a Spot Instance state change.

type SpotInstanceStatus 

type SpotInstanceStatus struct {
	// The date and time of the most recent status update, in UTC format (for example,
	// YYYY-MM-DDTHH:MM:SSZ).
	UpdateTime *time.Time
	// The description for the status code.
	Message *string
	// The status code. For a list of status codes, see Spot status codes
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-bid-status.html#spot-instance-bid-status-understand)
	// in the Amazon EC2 User Guide for Linux Instances.
	Code *string
}

Describes the status of a Spot Instance request.

type SpotInstanceType 

type SpotInstanceType string
const (
	SpotInstanceTypeOneTime    SpotInstanceType = "one-time"
	SpotInstanceTypePersistent SpotInstanceType = "persistent"
)

Enum values for SpotInstanceType

type SpotMarketOptions 

type SpotMarketOptions struct {
	// The Spot Instance request type. For RunInstances
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances),
	// persistent Spot Instance requests are only supported when
	// InstanceInterruptionBehavior is set to either hibernate or stop.
	SpotInstanceType SpotInstanceType
	// The behavior when a Spot Instance is interrupted. The default is terminate.
	InstanceInterruptionBehavior InstanceInterruptionBehavior
	// The end date of the request. For a one-time request, the request remains active
	// until all instances launch, the request is canceled, or this date is reached. If
	// the request is persistent, it remains active until it is canceled or this date
	// and time is reached. The default end date is 7 days from the current date.
	ValidUntil *time.Time
	// The required duration for the Spot Instances (also known as Spot blocks), in
	// minutes. This value must be a multiple of 60 (60, 120, 180, 240, 300, or 360).
	BlockDurationMinutes *int32
	// The maximum hourly price you're willing to pay for the Spot Instances. The
	// default is the On-Demand price.
	MaxPrice *string
}

The options for Spot Instances.

type SpotOptions 

type SpotOptions struct {
	// Indicates that the fleet launches all Spot Instances into a single Availability
	// Zone. Supported only for fleets of type instant.
	SingleAvailabilityZone *bool
	// The minimum target capacity for Spot Instances in the fleet. If the minimum
	// target capacity is not reached, the fleet launches no instances.
	MinTargetCapacity *int32
	// The behavior when a Spot Instance is interrupted. The default is terminate.
	InstanceInterruptionBehavior SpotInstanceInterruptionBehavior
	// Indicates how to allocate the target Spot Instance capacity across the Spot
	// Instance pools specified by the EC2 Fleet. If the allocation strategy is
	// lowest-price, EC2 Fleet launches instances from the Spot Instance pools with the
	// lowest price. This is the default allocation strategy. If the allocation
	// strategy is diversified, EC2 Fleet launches instances from all of the Spot
	// Instance pools that you specify. If the allocation strategy is
	// capacity-optimized, EC2 Fleet launches instances from Spot Instance pools with
	// optimal capacity for the number of instances that are launching.
	AllocationStrategy SpotAllocationStrategy
	// The number of Spot pools across which to allocate your target Spot capacity.
	// Valid only when AllocationStrategy is set to lowest-price. EC2 Fleet selects the
	// cheapest Spot pools and evenly allocates your target Spot capacity across the
	// number of Spot pools that you specify.
	InstancePoolsToUseCount *int32
	// Indicates that the fleet uses a single instance type to launch all Spot
	// Instances in the fleet. Supported only for fleets of type instant.
	SingleInstanceType *bool
	// The maximum amount per hour for Spot Instances that you're willing to pay.
	MaxTotalPrice *string
}

Describes the configuration of Spot Instances in an EC2 Fleet.

type SpotOptionsRequest 

type SpotOptionsRequest struct {
	// The maximum amount per hour for Spot Instances that you're willing to pay.
	MaxTotalPrice *string
	// The minimum target capacity for Spot Instances in the fleet. If the minimum
	// target capacity is not reached, the fleet launches no instances.
	MinTargetCapacity *int32
	// The number of Spot pools across which to allocate your target Spot capacity.
	// Valid only when Spot AllocationStrategy is set to lowest-price. EC2 Fleet
	// selects the cheapest Spot pools and evenly allocates your target Spot capacity
	// across the number of Spot pools that you specify.
	InstancePoolsToUseCount *int32
	// Indicates how to allocate the target Spot Instance capacity across the Spot
	// Instance pools specified by the EC2 Fleet. If the allocation strategy is
	// lowest-price, EC2 Fleet launches instances from the Spot Instance pools with the
	// lowest price. This is the default allocation strategy. If the allocation
	// strategy is diversified, EC2 Fleet launches instances from all of the Spot
	// Instance pools that you specify. If the allocation strategy is
	// capacity-optimized, EC2 Fleet launches instances from Spot Instance pools with
	// optimal capacity for the number of instances that are launching.
	AllocationStrategy SpotAllocationStrategy
	// Indicates that the fleet uses a single instance type to launch all Spot
	// Instances in the fleet. Supported only for fleets of type instant.
	SingleInstanceType *bool
	// Indicates that the fleet launches all Spot Instances into a single Availability
	// Zone. Supported only for fleets of type instant.
	SingleAvailabilityZone *bool
	// The behavior when a Spot Instance is interrupted. The default is terminate.
	InstanceInterruptionBehavior SpotInstanceInterruptionBehavior
}

Describes the configuration of Spot Instances in an EC2 Fleet request.

type SpotPlacement 

type SpotPlacement struct {
	// The tenancy of the instance (if the instance is running in a VPC). An instance
	// with a tenancy of dedicated runs on single-tenant hardware. The host tenancy is
	// not supported for Spot Instances.
	Tenancy Tenancy
	// The Availability Zone. [Spot Fleet only] To specify multiple Availability Zones,
	// separate them using commas; for example, "us-west-2a, us-west-2b".
	AvailabilityZone *string
	// The name of the placement group.
	GroupName *string
}

Describes Spot Instance placement.

type SpotPrice 

type SpotPrice struct {
	// The maximum price per hour that you are willing to pay for a Spot Instance.
	SpotPrice *string
	// The instance type.
	InstanceType InstanceType
	// A general description of the AMI.
	ProductDescription RIProductDescription
	// The date and time the request was created, in UTC format (for example,
	// YYYY-MM-DDTHH:MM:SSZ).
	Timestamp *time.Time
	// The Availability Zone.
	AvailabilityZone *string
}

Describes the maximum price per hour that you are willing to pay for a Spot Instance.

type StaleIpPermission 

type StaleIpPermission struct {
	// The end of the port range for the TCP and UDP protocols, or an ICMP type number.
	// A value of -1 indicates all ICMP types.
	ToPort *int32
	// The security group pairs. Returns the ID of the referenced security group and
	// VPC, and the ID and status of the VPC peering connection.
	UserIdGroupPairs []*UserIdGroupPair
	// The IP protocol name (for tcp, udp, and icmp) or number (see Protocol Numbers)
	// (http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml).
	IpProtocol *string
	// The prefix list IDs. Not applicable for stale security group rules.
	PrefixListIds []*string
	// The IP ranges. Not applicable for stale security group rules.
	IpRanges []*string
	// The start of the port range for the TCP and UDP protocols, or an ICMP type
	// number. A value of -1 indicates all ICMP types.
	FromPort *int32
}

Describes a stale rule in a security group.

type StaleSecurityGroup 

type StaleSecurityGroup struct {
	// The name of the security group.
	GroupName *string
	// Information about the stale outbound rules in the security group.
	StaleIpPermissionsEgress []*StaleIpPermission
	// The ID of the VPC for the security group.
	VpcId *string
	// Information about the stale inbound rules in the security group.
	StaleIpPermissions []*StaleIpPermission
	// The ID of the security group.
	GroupId *string
	// The description of the security group.
	Description *string
}

Describes a stale security group (a security group that contains stale rules).

type State 

type State string
const (
	StatePendingacceptance State = "PendingAcceptance"
	StatePending           State = "Pending"
	StateAvailable         State = "Available"
	StateDeleting          State = "Deleting"
	StateDeleted           State = "Deleted"
	StateRejected          State = "Rejected"
	StateFailed            State = "Failed"
	StateExpired           State = "Expired"
)

Enum values for State

type StateReason 

type StateReason struct {
	// The reason code for the state change.
	Code *string
	// The message for the state change.
	//
	//     * Server.InsufficientInstanceCapacity:
	// There was insufficient capacity available to satisfy the launch request.
	//
	//     *
	// Server.InternalError: An internal error caused the instance to terminate during
	// launch.
	//
	//     * Server.ScheduledStop: The instance was stopped due to a scheduled
	// retirement.
	//
	//     * Server.SpotInstanceShutdown: The instance was stopped because
	// the number of Spot requests with a maximum price equal to or higher than the
	// Spot price exceeded available capacity or because of an increase in the Spot
	// price.
	//
	//     * Server.SpotInstanceTermination: The instance was terminated
	// because the number of Spot requests with a maximum price equal to or higher than
	// the Spot price exceeded available capacity or because of an increase in the Spot
	// price.
	//
	//     * Client.InstanceInitiatedShutdown: The instance was shut down using
	// the shutdown -h command from the instance.
	//
	//     * Client.InstanceTerminated: The
	// instance was terminated or rebooted during AMI creation.
	//
	//     *
	// Client.InternalError: A client error caused the instance to terminate during
	// launch.
	//
	//     * Client.InvalidSnapshot.NotFound: The specified snapshot was not
	// found.
	//
	//     * Client.UserInitiatedHibernate: Hibernation was initiated on the
	// instance.
	//
	//     * Client.UserInitiatedShutdown: The instance was shut down using
	// the Amazon EC2 API.
	//
	//     * Client.VolumeLimitExceeded: The limit on the number
	// of EBS volumes or total storage was exceeded. Decrease usage or request an
	// increase in your account limits.
	Message *string
}

Describes a state change.

type Status 

type Status string
const (
	StatusMoveinprogress Status = "MoveInProgress"
	StatusInvpc          Status = "InVpc"
	StatusInclassic      Status = "InClassic"
)

Enum values for Status

type StatusName 

type StatusName string
const (
	StatusNameReachability StatusName = "reachability"
)

Enum values for StatusName

type StatusType 

type StatusType string
const (
	StatusTypePassed           StatusType = "passed"
	StatusTypeFailed           StatusType = "failed"
	StatusTypeInsufficientData StatusType = "insufficient-data"
	StatusTypeInitializing     StatusType = "initializing"
)

Enum values for StatusType

type Storage 

type Storage struct {
	// An Amazon S3 storage location.
	S3 *S3Storage
}

Describes the storage location for an instance store-backed AMI.

type StorageLocation 

type StorageLocation struct {
	// The name of the S3 bucket.
	Bucket *string
	// The key.
	Key *string
}

Describes a storage location in Amazon S3.

type Subnet 

type Subnet struct {
	// The Availability Zone of the subnet.
	AvailabilityZone *string
	// The ID of the VPC the subnet is in.
	VpcId *string
	// Indicates whether a network interface created in this subnet (including a
	// network interface created by RunInstances ()) receives a customer-owned IPv4
	// address.
	MapCustomerOwnedIpOnLaunch *bool
	// Indicates whether this is the default subnet for the Availability Zone.
	DefaultForAz *bool
	// The AZ ID of the subnet.
	AvailabilityZoneId *string
	// The number of unused private IPv4 addresses in the subnet. The IPv4 addresses
	// for any stopped instances are considered unavailable.
	AvailableIpAddressCount *int32
	// Indicates whether a network interface created in this subnet (including a
	// network interface created by RunInstances ()) receives an IPv6 address.
	AssignIpv6AddressOnCreation *bool
	// Any tags assigned to the subnet.
	Tags []*Tag
	// The ID of the AWS account that owns the subnet.
	OwnerId *string
	// The ID of the subnet.
	SubnetId *string
	// Information about the IPv6 CIDR blocks associated with the subnet.
	Ipv6CidrBlockAssociationSet []*SubnetIpv6CidrBlockAssociation
	// The customer-owned IPv4 address pool associated with the subnet.
	CustomerOwnedIpv4Pool *string
	// The IPv4 CIDR block assigned to the subnet.
	CidrBlock *string
	// Indicates whether instances launched in this subnet receive a public IPv4
	// address.
	MapPublicIpOnLaunch *bool
	// The current state of the subnet.
	State SubnetState
	// The Amazon Resource Name (ARN) of the subnet.
	SubnetArn *string
	// The Amazon Resource Name (ARN) of the Outpost.
	OutpostArn *string
}

Describes a subnet.

type SubnetAssociation 

type SubnetAssociation struct {
	// The state of the subnet association.
	State TransitGatewayMulitcastDomainAssociationState
	// The ID of the subnet.
	SubnetId *string
}

Describes the subnet association with the transit gateway multicast domain.

type SubnetCidrBlockState 

type SubnetCidrBlockState struct {
	// A message about the status of the CIDR block, if applicable.
	StatusMessage *string
	// The state of a CIDR block.
	State SubnetCidrBlockStateCode
}

Describes the state of a CIDR block.

type SubnetCidrBlockStateCode 

type SubnetCidrBlockStateCode string
const (
	SubnetCidrBlockStateCodeAssociating    SubnetCidrBlockStateCode = "associating"
	SubnetCidrBlockStateCodeAssociated     SubnetCidrBlockStateCode = "associated"
	SubnetCidrBlockStateCodeDisassociating SubnetCidrBlockStateCode = "disassociating"
	SubnetCidrBlockStateCodeDisassociated  SubnetCidrBlockStateCode = "disassociated"
	SubnetCidrBlockStateCodeFailing        SubnetCidrBlockStateCode = "failing"
	SubnetCidrBlockStateCodeFailed         SubnetCidrBlockStateCode = "failed"
)

Enum values for SubnetCidrBlockStateCode

type SubnetIpv6CidrBlockAssociation 

type SubnetIpv6CidrBlockAssociation struct {
	// The IPv6 CIDR block.
	Ipv6CidrBlock *string
	// The association ID for the CIDR block.
	AssociationId *string
	// Information about the state of the CIDR block.
	Ipv6CidrBlockState *SubnetCidrBlockState
}

Describes an IPv6 CIDR block associated with a subnet.

type SubnetState 

type SubnetState string
const (
	SubnetStatePending   SubnetState = "pending"
	SubnetStateAvailable SubnetState = "available"
)

Enum values for SubnetState

type SuccessfulInstanceCreditSpecificationItem 

type SuccessfulInstanceCreditSpecificationItem struct {
	// The ID of the instance.
	InstanceId *string
}

Describes the burstable performance instance whose credit option for CPU usage was successfully modified.

type SuccessfulQueuedPurchaseDeletion 

type SuccessfulQueuedPurchaseDeletion struct {
	// The ID of the Reserved Instance.
	ReservedInstancesId *string
}

Describes a Reserved Instance whose queued purchase was successfully deleted.

type SummaryStatus 

type SummaryStatus string
const (
	SummaryStatusOk               SummaryStatus = "ok"
	SummaryStatusImpaired         SummaryStatus = "impaired"
	SummaryStatusInsufficientData SummaryStatus = "insufficient-data"
	SummaryStatusNotApplicable    SummaryStatus = "not-applicable"
	SummaryStatusInitializing     SummaryStatus = "initializing"
)

Enum values for SummaryStatus

type Tag 

type Tag struct {
	// The value of the tag. Constraints: Tag values are case-sensitive and accept a
	// maximum of 255 Unicode characters.
	Value *string
	// The key of the tag. Constraints: Tag keys are case-sensitive and accept a
	// maximum of 127 Unicode characters. May not begin with aws:.
	Key *string
}

Describes a tag.

type TagDescription 

type TagDescription struct {
	// The tag value.
	Value *string
	// The resource type.
	ResourceType ResourceType
	// The ID of the resource.
	ResourceId *string
	// The tag key.
	Key *string
}

Describes a tag.

type TagSpecification 

type TagSpecification struct {
	// The type of resource to tag. Currently, the resource types that support tagging
	// on creation are: capacity-reservation | client-vpn-endpoint | customer-gateway |
	// dedicated-host | dhcp-options | export-image-task | export-instance-task | fleet
	// | fpga-image | host-reservation | import-image-task | import-snapshot-task |
	// instance | internet-gateway | ipv4pool-ec2 | ipv6pool-ec2 | key-pair |
	// launch-template | placement-group | prefix-list | natgateway | network-acl |
	// route-table | security-group | spot-fleet-request | spot-instances-request |
	// snapshot | subnet | traffic-mirror-filter | traffic-mirror-session |
	// traffic-mirror-target | transit-gateway | transit-gateway-attachment |
	// transit-gateway-route-table | volume |vpc |  vpc-peering-connection |
	// vpc-endpoint (for interface and gateway endpoints) | vpc-endpoint-service (for
	// AWS PrivateLink) | vpc-flow-log | vpn-connection | vpn-gateway. To tag a
	// resource after it has been created, see CreateTags
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTags.html).
	ResourceType ResourceType
	// The tags to apply to the resource.
	Tags []*Tag
}

The tags to apply to a resource when the resource is being created.

type TargetCapacitySpecification 

type TargetCapacitySpecification struct {
	// The number of On-Demand units to request. If you specify a target capacity for
	// Spot units, you cannot specify a target capacity for On-Demand units.
	OnDemandTargetCapacity *int32
	// The default TotalTargetCapacity, which is either Spot or On-Demand.
	DefaultTargetCapacityType DefaultTargetCapacityType
	// The maximum number of Spot units to launch. If you specify a target capacity for
	// On-Demand units, you cannot specify a target capacity for Spot units.
	SpotTargetCapacity *int32
	// The number of units to request, filled using DefaultTargetCapacityType.
	TotalTargetCapacity *int32
}

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. You can use the On-Demand Instance MaxTotalPrice parameter, the Spot Instance MaxTotalPrice, or both to ensure that your fleet cost does not exceed your budget. If you set a maximum price per hour for the On-Demand Instances and Spot Instances in your request, EC2 Fleet will launch instances until it reaches the maximum amount that you're willing to pay. When the maximum amount you're willing to pay is reached, the fleet stops launching instances even if it hasn’t met the target capacity. The MaxTotalPrice parameters are located in OnDemandOptions (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_OnDemandOptions.html) and SpotOptions (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotOptions)

type TargetCapacitySpecificationRequest 

type TargetCapacitySpecificationRequest struct {
	// The number of units to request, filled using DefaultTargetCapacityType.
	TotalTargetCapacity *int32
	// The number of Spot units to request.
	SpotTargetCapacity *int32
	// The number of On-Demand units to request.
	OnDemandTargetCapacity *int32
	// The default TotalTargetCapacity, which is either Spot or On-Demand.
	DefaultTargetCapacityType DefaultTargetCapacityType
}

The number of units to request. You can choose to set the target capacity as the number of instances. Or you can set the target capacity to 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. You can use the On-Demand Instance MaxTotalPrice parameter, the Spot Instance MaxTotalPrice parameter, or both parameters to ensure that your fleet cost does not exceed your budget. If you set a maximum price per hour for the On-Demand Instances and Spot Instances in your request, EC2 Fleet will launch instances until it reaches the maximum amount that you're willing to pay. When the maximum amount you're willing to pay is reached, the fleet stops launching instances even if it hasn’t met the target capacity. The MaxTotalPrice parameters are located in OnDemandOptionsRequest (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_OnDemandOptionsRequest) and SpotOptionsRequest (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotOptionsRequest).

type TargetConfiguration 

type TargetConfiguration struct {
	// The number of instances the Convertible Reserved Instance offering can be
	// applied to. This parameter is reserved and cannot be specified in a request
	InstanceCount *int32
	// The ID of the Convertible Reserved Instance offering.
	OfferingId *string
}

Information about the Convertible Reserved Instance offering.

type TargetConfigurationRequest 

type TargetConfigurationRequest struct {
	// The Convertible Reserved Instance offering ID.
	OfferingId *string
	// The number of instances the Covertible Reserved Instance offering can be applied
	// to. This parameter is reserved and cannot be specified in a request
	InstanceCount *int32
}

Details about the target configuration.

type TargetGroup 

type TargetGroup struct {
	// The Amazon Resource Name (ARN) of the target group.
	Arn *string
}

Describes a load balancer target group.

type TargetGroupsConfig 

type TargetGroupsConfig struct {
	// One or more target groups.
	TargetGroups []*TargetGroup
}

Describes the target groups to attach to a Spot Fleet. Spot Fleet registers the running Spot Instances with these target groups.

type TargetNetwork 

type TargetNetwork struct {
	// The IDs of the security groups applied to the target network association.
	SecurityGroups []*string
	// The current state of the target network association.
	Status *AssociationStatus
	// The ID of the VPC in which the target network (subnet) is located.
	VpcId *string
	// The ID of the subnet specified as the target network.
	TargetNetworkId *string
	// The ID of the association.
	AssociationId *string
	// The ID of the Client VPN endpoint with which the target network is associated.
	ClientVpnEndpointId *string
}

Describes a target network associated with a Client VPN endpoint.

type TargetReservationValue 

type TargetReservationValue struct {
	// The total value of the Convertible Reserved Instances that make up the exchange.
	// This is the sum of the list value, remaining upfront price, and additional
	// upfront cost of the exchange.
	ReservationValue *ReservationValue
	// The configuration of the Convertible Reserved Instances that make up the
	// exchange.
	TargetConfiguration *TargetConfiguration
}

The total value of the new Convertible Reserved Instances.

type TelemetryStatus 

type TelemetryStatus string
const (
	TelemetryStatusUp   TelemetryStatus = "UP"
	TelemetryStatusDown TelemetryStatus = "DOWN"
)

Enum values for TelemetryStatus

type Tenancy 

type Tenancy string
const (
	TenancyDefault   Tenancy = "default"
	TenancyDedicated Tenancy = "dedicated"
	TenancyHost      Tenancy = "host"
)

Enum values for Tenancy

type TerminateConnectionStatus 

type TerminateConnectionStatus struct {
	// The state of the client connection.
	PreviousStatus *ClientVpnConnectionStatus
	// A message about the status of the client connection, if applicable.
	CurrentStatus *ClientVpnConnectionStatus
	// The ID of the client connection.
	ConnectionId *string
}

Information about a terminated Client VPN endpoint client connection.

type TrafficDirection 

type TrafficDirection string
const (
	TrafficDirectionIngress TrafficDirection = "ingress"
	TrafficDirectionEgress  TrafficDirection = "egress"
)

Enum values for TrafficDirection

type TrafficMirrorFilter 

type TrafficMirrorFilter struct {
	// The network service traffic that is associated with the Traffic Mirror filter.
	NetworkServices []TrafficMirrorNetworkService
	// Information about the egress rules that are associated with the Traffic Mirror
	// filter.
	EgressFilterRules []*TrafficMirrorFilterRule
	// Information about the ingress rules that are associated with the Traffic Mirror
	// filter.
	IngressFilterRules []*TrafficMirrorFilterRule
	// The ID of the Traffic Mirror filter.
	TrafficMirrorFilterId *string
	// The description of the Traffic Mirror filter.
	Description *string
	// The tags assigned to the Traffic Mirror filter.
	Tags []*Tag
}

Describes the Traffic Mirror filter.

type TrafficMirrorFilterRule 

type TrafficMirrorFilterRule struct {
	// The source port range assigned to the Traffic Mirror rule.
	SourcePortRange *TrafficMirrorPortRange
	// The destination port range assigned to the Traffic Mirror rule.
	DestinationPortRange *TrafficMirrorPortRange
	// The action assigned to the Traffic Mirror rule.
	RuleAction TrafficMirrorRuleAction
	// The destination CIDR block assigned to the Traffic Mirror rule.
	DestinationCidrBlock *string
	// The ID of the Traffic Mirror filter that the rule is associated with.
	TrafficMirrorFilterId *string
	// The protocol assigned to the Traffic Mirror rule.
	Protocol *int32
	// The source CIDR block assigned to the Traffic Mirror rule.
	SourceCidrBlock *string
	// The rule number of the Traffic Mirror rule.
	RuleNumber *int32
	// The description of the Traffic Mirror rule.
	Description *string
	// The ID of the Traffic Mirror rule.
	TrafficMirrorFilterRuleId *string
	// The traffic direction assigned to the Traffic Mirror rule.
	TrafficDirection TrafficDirection
}

Describes the Traffic Mirror rule.

type TrafficMirrorFilterRuleField 

type TrafficMirrorFilterRuleField string
const (
	TrafficMirrorFilterRuleFieldDestinationPortRange TrafficMirrorFilterRuleField = "destination-port-range"
	TrafficMirrorFilterRuleFieldSourcePortRange      TrafficMirrorFilterRuleField = "source-port-range"
	TrafficMirrorFilterRuleFieldProtocol             TrafficMirrorFilterRuleField = "protocol"
	TrafficMirrorFilterRuleFieldDescription          TrafficMirrorFilterRuleField = "description"
)

Enum values for TrafficMirrorFilterRuleField

type TrafficMirrorNetworkService 

type TrafficMirrorNetworkService string
const (
	TrafficMirrorNetworkServiceAmazonDns TrafficMirrorNetworkService = "amazon-dns"
)

Enum values for TrafficMirrorNetworkService

type TrafficMirrorPortRange 

type TrafficMirrorPortRange struct {
	// The start of the Traffic Mirror port range. This applies to the TCP and UDP
	// protocols.
	FromPort *int32
	// The end of the Traffic Mirror port range. This applies to the TCP and UDP
	// protocols.
	ToPort *int32
}

Describes the Traffic Mirror port range.

type TrafficMirrorPortRangeRequest 

type TrafficMirrorPortRangeRequest struct {
	// The first port in the Traffic Mirror port range. This applies to the TCP and UDP
	// protocols.
	FromPort *int32
	// The last port in the Traffic Mirror port range. This applies to the TCP and UDP
	// protocols.
	ToPort *int32
}

Information about the Traffic Mirror filter rule port range.

type TrafficMirrorRuleAction 

type TrafficMirrorRuleAction string
const (
	TrafficMirrorRuleActionAccept TrafficMirrorRuleAction = "accept"
	TrafficMirrorRuleActionReject TrafficMirrorRuleAction = "reject"
)

Enum values for TrafficMirrorRuleAction

type TrafficMirrorSession 

type TrafficMirrorSession struct {
	// The ID of the Traffic Mirror target.
	TrafficMirrorTargetId *string
	// The tags assigned to the Traffic Mirror session.
	Tags []*Tag
	// The ID of the Traffic Mirror filter.
	TrafficMirrorFilterId *string
	// The virtual network ID associated with the Traffic Mirror session.
	VirtualNetworkId *int32
	// The description of the Traffic Mirror session.
	Description *string
	// The ID of the account that owns the Traffic Mirror session.
	OwnerId *string
	// The ID of the Traffic Mirror session's network interface.
	NetworkInterfaceId *string
	// The ID for the Traffic Mirror session.
	TrafficMirrorSessionId *string
	// The session number determines the order in which sessions are evaluated when an
	// interface is used by multiple sessions. The first session with a matching filter
	// is the one that mirrors the packets. Valid values are 1-32766.
	SessionNumber *int32
	// The number of bytes in each packet to mirror. These are the bytes after the
	// VXLAN header. To mirror a subset, set this to the length (in bytes) to mirror.
	// For example, if you set this value to 100, then the first 100 bytes that meet
	// the filter criteria are copied to the target. Do not specify this parameter when
	// you want to mirror the entire packet
	PacketLength *int32
}

Describes a Traffic Mirror session.

type TrafficMirrorSessionField 

type TrafficMirrorSessionField string
const (
	TrafficMirrorSessionFieldPacketLength     TrafficMirrorSessionField = "packet-length"
	TrafficMirrorSessionFieldDescription      TrafficMirrorSessionField = "description"
	TrafficMirrorSessionFieldVirtualNetworkId TrafficMirrorSessionField = "virtual-network-id"
)

Enum values for TrafficMirrorSessionField

type TrafficMirrorTarget 

type TrafficMirrorTarget struct {
	// The network interface ID that is attached to the target.
	NetworkInterfaceId *string
	// The ID of the account that owns the Traffic Mirror target.
	OwnerId *string
	// The type of Traffic Mirror target.
	Type TrafficMirrorTargetType
	// The tags assigned to the Traffic Mirror target.
	Tags []*Tag
	// The ID of the Traffic Mirror target.
	TrafficMirrorTargetId *string
	// The Amazon Resource Name (ARN) of the Network Load Balancer.
	NetworkLoadBalancerArn *string
	// Information about the Traffic Mirror target.
	Description *string
}

Describes a Traffic Mirror target.

type TrafficMirrorTargetType 

type TrafficMirrorTargetType string
const (
	TrafficMirrorTargetTypeNetworkInterface    TrafficMirrorTargetType = "network-interface"
	TrafficMirrorTargetTypeNetworkLoadBalancer TrafficMirrorTargetType = "network-load-balancer"
)

Enum values for TrafficMirrorTargetType

type TrafficType 

type TrafficType string
const (
	TrafficTypeAccept TrafficType = "ACCEPT"
	TrafficTypeReject TrafficType = "REJECT"
	TrafficTypeAll    TrafficType = "ALL"
)

Enum values for TrafficType

type TransitGateway 

type TransitGateway struct {
	// The ID of the AWS account ID that owns the transit gateway.
	OwnerId *string
	// The Amazon Resource Name (ARN) of the transit gateway.
	TransitGatewayArn *string
	// The state of the transit gateway.
	State TransitGatewayState
	// The creation time.
	CreationTime *time.Time
	// The tags for the transit gateway.
	Tags []*Tag
	// The ID of the transit gateway.
	TransitGatewayId *string
	// The transit gateway options.
	Options *TransitGatewayOptions
	// The description of the transit gateway.
	Description *string
}

Describes a transit gateway.

type TransitGatewayAssociation 

type TransitGatewayAssociation struct {
	// The state of the association.
	State TransitGatewayAssociationState
	// The ID of the transit gateway route table.
	TransitGatewayRouteTableId *string
	// The resource type.
	ResourceType TransitGatewayAttachmentResourceType
	// The ID of the resource.
	ResourceId *string
	// The ID of the attachment.
	TransitGatewayAttachmentId *string
}

Describes an association between a resource attachment and a transit gateway route table.

type TransitGatewayAssociationState 

type TransitGatewayAssociationState string
const (
	TransitGatewayAssociationStateAssociating    TransitGatewayAssociationState = "associating"
	TransitGatewayAssociationStateAssociated     TransitGatewayAssociationState = "associated"
	TransitGatewayAssociationStateDisassociating TransitGatewayAssociationState = "disassociating"
	TransitGatewayAssociationStateDisassociated  TransitGatewayAssociationState = "disassociated"
)

Enum values for TransitGatewayAssociationState

type TransitGatewayAttachment 

type TransitGatewayAttachment struct {
	// The ID of the resource.
	ResourceId *string
	// The resource type.
	ResourceType TransitGatewayAttachmentResourceType
	// The ID of the transit gateway.
	TransitGatewayId *string
	// The tags for the attachment.
	Tags []*Tag
	// The creation time.
	CreationTime *time.Time
	// The attachment state.
	State TransitGatewayAttachmentState
	// The ID of the AWS account that owns the transit gateway.
	TransitGatewayOwnerId *string
	// The ID of the AWS account that owns the resource.
	ResourceOwnerId *string
	// The ID of the attachment.
	TransitGatewayAttachmentId *string
	// The association.
	Association *TransitGatewayAttachmentAssociation
}

Describes an attachment between a resource and a transit gateway.

type TransitGatewayAttachmentAssociation 

type TransitGatewayAttachmentAssociation struct {
	// The state of the association.
	State TransitGatewayAssociationState
	// The ID of the route table for the transit gateway.
	TransitGatewayRouteTableId *string
}

Describes an association.

type TransitGatewayAttachmentPropagation 

type TransitGatewayAttachmentPropagation struct {
	// The ID of the propagation route table.
	TransitGatewayRouteTableId *string
	// The state of the propagation route table.
	State TransitGatewayPropagationState
}

Describes a propagation route table.

type TransitGatewayAttachmentResourceType 

type TransitGatewayAttachmentResourceType string
const (
	TransitGatewayAttachmentResourceTypeVpc                  TransitGatewayAttachmentResourceType = "vpc"
	TransitGatewayAttachmentResourceTypeVpn                  TransitGatewayAttachmentResourceType = "vpn"
	TransitGatewayAttachmentResourceTypeDirectConnectGateway TransitGatewayAttachmentResourceType = "direct-connect-gateway"
	TransitGatewayAttachmentResourceTypeTgwPeering           TransitGatewayAttachmentResourceType = "tgw-peering"
)

Enum values for TransitGatewayAttachmentResourceType

type TransitGatewayAttachmentState 

type TransitGatewayAttachmentState string
const (
	TransitGatewayAttachmentStateInitiating        TransitGatewayAttachmentState = "initiating"
	TransitGatewayAttachmentStatePendingacceptance TransitGatewayAttachmentState = "pendingAcceptance"
	TransitGatewayAttachmentStateRollingback       TransitGatewayAttachmentState = "rollingBack"
	TransitGatewayAttachmentStatePending           TransitGatewayAttachmentState = "pending"
	TransitGatewayAttachmentStateAvailable         TransitGatewayAttachmentState = "available"
	TransitGatewayAttachmentStateModifying         TransitGatewayAttachmentState = "modifying"
	TransitGatewayAttachmentStateDeleting          TransitGatewayAttachmentState = "deleting"
	TransitGatewayAttachmentStateDeleted           TransitGatewayAttachmentState = "deleted"
	TransitGatewayAttachmentStateFailed            TransitGatewayAttachmentState = "failed"
	TransitGatewayAttachmentStateRejected          TransitGatewayAttachmentState = "rejected"
	TransitGatewayAttachmentStateRejecting         TransitGatewayAttachmentState = "rejecting"
	TransitGatewayAttachmentStateFailing           TransitGatewayAttachmentState = "failing"
)

Enum values for TransitGatewayAttachmentState

type TransitGatewayMulitcastDomainAssociationState 

type TransitGatewayMulitcastDomainAssociationState string
const (
	TransitGatewayMulitcastDomainAssociationStateAssociating    TransitGatewayMulitcastDomainAssociationState = "associating"
	TransitGatewayMulitcastDomainAssociationStateAssociated     TransitGatewayMulitcastDomainAssociationState = "associated"
	TransitGatewayMulitcastDomainAssociationStateDisassociating TransitGatewayMulitcastDomainAssociationState = "disassociating"
	TransitGatewayMulitcastDomainAssociationStateDisassociated  TransitGatewayMulitcastDomainAssociationState = "disassociated"
)

Enum values for TransitGatewayMulitcastDomainAssociationState

type TransitGatewayMulticastDeregisteredGroupMembers 

type TransitGatewayMulticastDeregisteredGroupMembers struct {
	// The IP address assigned to the transit gateway multicast group.
	GroupIpAddress *string
	// The ID of the transit gateway multicast domain.
	TransitGatewayMulticastDomainId *string
	// The network interface IDs of the deregistered members.
	DeregisteredNetworkInterfaceIds []*string
}

Describes the deregistered transit gateway multicast group members.

type TransitGatewayMulticastDeregisteredGroupSources 

type TransitGatewayMulticastDeregisteredGroupSources struct {
	// The ID of the transit gateway multicast domain.
	TransitGatewayMulticastDomainId *string
	// The network interface IDs of the non-registered members.
	DeregisteredNetworkInterfaceIds []*string
	// The IP address assigned to the transit gateway multicast group.
	GroupIpAddress *string
}

Describes the deregistered transit gateway multicast group sources.

type TransitGatewayMulticastDomain 

type TransitGatewayMulticastDomain struct {
	// The time the transit gateway multicast domain was created.
	CreationTime *time.Time
	// The ID of the transit gateway.
	TransitGatewayId *string
	// The ID of the transit gateway multicast domain.
	TransitGatewayMulticastDomainId *string
	// The state of the transit gateway multicast domain.
	State TransitGatewayMulticastDomainState
	// The tags for the transit gateway multicast domain.
	Tags []*Tag
}

Describes the transit gateway multicast domain.

type TransitGatewayMulticastDomainAssociation 

type TransitGatewayMulticastDomainAssociation struct {
	// The ID of the resource.
	ResourceId *string
	// The subnet associated with the transit gateway multicast domain.
	Subnet *SubnetAssociation
	// The type of resource, for example a VPC attachment.
	ResourceType TransitGatewayAttachmentResourceType
	// The ID of the transit gateway attachment.
	TransitGatewayAttachmentId *string
}

Describes the resources associated with the transit gateway multicast domain.

type TransitGatewayMulticastDomainAssociations 

type TransitGatewayMulticastDomainAssociations struct {
	// The ID of the transit gateway multicast domain.
	TransitGatewayMulticastDomainId *string
	// The ID of the transit gateway attachment.
	TransitGatewayAttachmentId *string
	// The ID of the resource.
	ResourceId *string
	// The subnets associated with the multicast domain.
	Subnets []*SubnetAssociation
	// The type of resource, for example a VPC attachment.
	ResourceType TransitGatewayAttachmentResourceType
}

Describes the multicast domain associations.

type TransitGatewayMulticastDomainState 

type TransitGatewayMulticastDomainState string
const (
	TransitGatewayMulticastDomainStatePending   TransitGatewayMulticastDomainState = "pending"
	TransitGatewayMulticastDomainStateAvailable TransitGatewayMulticastDomainState = "available"
	TransitGatewayMulticastDomainStateDeleting  TransitGatewayMulticastDomainState = "deleting"
	TransitGatewayMulticastDomainStateDeleted   TransitGatewayMulticastDomainState = "deleted"
)

Enum values for TransitGatewayMulticastDomainState

type TransitGatewayMulticastGroup 

type TransitGatewayMulticastGroup struct {
	// The IP address assigned to the transit gateway multicast group.
	GroupIpAddress *string
	// The member type (for example, static).
	MemberType MembershipType
	// The ID of the transit gateway attachment.
	TransitGatewayAttachmentId *string
	// The ID of the resource.
	ResourceId *string
	// Indicates that the resource is a transit gateway multicast group member.
	GroupSource *bool
	// The source type.
	SourceType MembershipType
	// Indicates that the resource is a transit gateway multicast group member.
	GroupMember *bool
	// The ID of the subnet.
	SubnetId *string
	// The ID of the transit gateway attachment.
	NetworkInterfaceId *string
	// The type of resource, for example a VPC attachment.
	ResourceType TransitGatewayAttachmentResourceType
}

Describes the transit gateway multicast group resources.

type TransitGatewayMulticastRegisteredGroupMembers 

type TransitGatewayMulticastRegisteredGroupMembers struct {
	// The ID of the transit gateway multicast domain.
	TransitGatewayMulticastDomainId *string
	// The ID of the registered network interfaces.
	RegisteredNetworkInterfaceIds []*string
	// The IP address assigned to the transit gateway multicast group.
	GroupIpAddress *string
}

Describes the registered transit gateway multicast group members.

type TransitGatewayMulticastRegisteredGroupSources 

type TransitGatewayMulticastRegisteredGroupSources struct {
	// The ID of the transit gateway multicast domain.
	TransitGatewayMulticastDomainId *string
	// The IP address assigned to the transit gateway multicast group.
	GroupIpAddress *string
	// The IDs of the network interfaces members registered with the transit gateway
	// multicast group.
	RegisteredNetworkInterfaceIds []*string
}

Describes the members registered with the transit gateway multicast group.

type TransitGatewayOptions 

type TransitGatewayOptions struct {
	// The ID of the default propagation route table.
	PropagationDefaultRouteTableId *string
	// Indicates whether multicast is enabled on the transit gateway
	MulticastSupport MulticastSupportValue
	// A private Autonomous System Number (ASN) for the Amazon side of a BGP session.
	// The range is 64512 to 65534 for 16-bit ASNs and 4200000000 to 4294967294 for
	// 32-bit ASNs.
	AmazonSideAsn *int64
	// Indicates whether DNS support is enabled.
	DnsSupport DnsSupportValue
	// The ID of the default association route table.
	AssociationDefaultRouteTableId *string
	// Indicates whether resource attachments automatically propagate routes to the
	// default propagation route table.
	DefaultRouteTablePropagation DefaultRouteTablePropagationValue
	// Indicates whether resource attachments are automatically associated with the
	// default association route table.
	DefaultRouteTableAssociation DefaultRouteTableAssociationValue
	// Indicates whether Equal Cost Multipath Protocol support is enabled.
	VpnEcmpSupport VpnEcmpSupportValue
	// Indicates whether attachment requests are automatically accepted.
	AutoAcceptSharedAttachments AutoAcceptSharedAttachmentsValue
}

Describes the options for a transit gateway.

type TransitGatewayPeeringAttachment 

type TransitGatewayPeeringAttachment struct {
	// The time the transit gateway peering attachment was created.
	CreationTime *time.Time
	// The status of the transit gateway peering attachment.
	Status *PeeringAttachmentStatus
	// The tags for the transit gateway peering attachment.
	Tags []*Tag
	// Information about the requester transit gateway.
	RequesterTgwInfo *PeeringTgwInfo
	// Information about the accepter transit gateway.
	AccepterTgwInfo *PeeringTgwInfo
	// The state of the transit gateway peering attachment.
	State TransitGatewayAttachmentState
	// The ID of the transit gateway peering attachment.
	TransitGatewayAttachmentId *string
}

Describes the transit gateway peering attachment.

type TransitGatewayPropagation 

type TransitGatewayPropagation struct {
	// The ID of the attachment.
	TransitGatewayAttachmentId *string
	// The state.
	State TransitGatewayPropagationState
	// The ID of the transit gateway route table.
	TransitGatewayRouteTableId *string
	// The resource type.
	ResourceType TransitGatewayAttachmentResourceType
	// The ID of the resource.
	ResourceId *string
}

Describes route propagation.

type TransitGatewayPropagationState 

type TransitGatewayPropagationState string
const (
	TransitGatewayPropagationStateEnabling  TransitGatewayPropagationState = "enabling"
	TransitGatewayPropagationStateEnabled   TransitGatewayPropagationState = "enabled"
	TransitGatewayPropagationStateDisabling TransitGatewayPropagationState = "disabling"
	TransitGatewayPropagationStateDisabled  TransitGatewayPropagationState = "disabled"
)

Enum values for TransitGatewayPropagationState

type TransitGatewayRequestOptions 

type TransitGatewayRequestOptions struct {
	// Enable or disable automatic association with the default association route
	// table. Enabled by default.
	DefaultRouteTableAssociation DefaultRouteTableAssociationValue
	// Indicates whether multicast is enabled on the transit gateway
	MulticastSupport MulticastSupportValue
	// Enable or disable DNS support. Enabled by default.
	DnsSupport DnsSupportValue
	// Enable or disable automatic acceptance of attachment requests. Disabled by
	// default.
	AutoAcceptSharedAttachments AutoAcceptSharedAttachmentsValue
	// Enable or disable automatic propagation of routes to the default propagation
	// route table. Enabled by default.
	DefaultRouteTablePropagation DefaultRouteTablePropagationValue
	// Enable or disable Equal Cost Multipath Protocol support. Enabled by default.
	VpnEcmpSupport VpnEcmpSupportValue
	// A private Autonomous System Number (ASN) for the Amazon side of a BGP session.
	// The range is 64512 to 65534 for 16-bit ASNs and 4200000000 to 4294967294 for
	// 32-bit ASNs. The default is 64512.
	AmazonSideAsn *int64
}

Describes the options for a transit gateway.

type TransitGatewayRoute 

type TransitGatewayRoute struct {
	// The CIDR block used for destination matches.
	DestinationCidrBlock *string
	// The state of the route.
	State TransitGatewayRouteState
	// The attachments.
	TransitGatewayAttachments []*TransitGatewayRouteAttachment
	// The route type.
	Type TransitGatewayRouteType
}

Describes a route for a transit gateway route table.

type TransitGatewayRouteAttachment 

type TransitGatewayRouteAttachment struct {
	// The ID of the attachment.
	TransitGatewayAttachmentId *string
	// The resource type.
	ResourceType TransitGatewayAttachmentResourceType
	// The ID of the resource.
	ResourceId *string
}

Describes a route attachment.

type TransitGatewayRouteState 

type TransitGatewayRouteState string
const (
	TransitGatewayRouteStatePending   TransitGatewayRouteState = "pending"
	TransitGatewayRouteStateActive    TransitGatewayRouteState = "active"
	TransitGatewayRouteStateBlackhole TransitGatewayRouteState = "blackhole"
	TransitGatewayRouteStateDeleting  TransitGatewayRouteState = "deleting"
	TransitGatewayRouteStateDeleted   TransitGatewayRouteState = "deleted"
)

Enum values for TransitGatewayRouteState

type TransitGatewayRouteTable 

type TransitGatewayRouteTable struct {
	// Indicates whether this is the default propagation route table for the transit
	// gateway.
	DefaultPropagationRouteTable *bool
	// The ID of the transit gateway route table.
	TransitGatewayRouteTableId *string
	// Any tags assigned to the route table.
	Tags []*Tag
	// The creation time.
	CreationTime *time.Time
	// Indicates whether this is the default association route table for the transit
	// gateway.
	DefaultAssociationRouteTable *bool
	// The state of the transit gateway route table.
	State TransitGatewayRouteTableState
	// The ID of the transit gateway.
	TransitGatewayId *string
}

Describes a transit gateway route table.

type TransitGatewayRouteTableAssociation 

type TransitGatewayRouteTableAssociation struct {
	// The ID of the resource.
	ResourceId *string
	// The ID of the attachment.
	TransitGatewayAttachmentId *string
	// The state of the association.
	State TransitGatewayAssociationState
	// The resource type.
	ResourceType TransitGatewayAttachmentResourceType
}

Describes an association between a route table and a resource attachment.

type TransitGatewayRouteTablePropagation 

type TransitGatewayRouteTablePropagation struct {
	// The type of resource.
	ResourceType TransitGatewayAttachmentResourceType
	// The ID of the resource.
	ResourceId *string
	// The ID of the attachment.
	TransitGatewayAttachmentId *string
	// The state of the resource.
	State TransitGatewayPropagationState
}

Describes a route table propagation.

type TransitGatewayRouteTableState 

type TransitGatewayRouteTableState string
const (
	TransitGatewayRouteTableStatePending   TransitGatewayRouteTableState = "pending"
	TransitGatewayRouteTableStateAvailable TransitGatewayRouteTableState = "available"
	TransitGatewayRouteTableStateDeleting  TransitGatewayRouteTableState = "deleting"
	TransitGatewayRouteTableStateDeleted   TransitGatewayRouteTableState = "deleted"
)

Enum values for TransitGatewayRouteTableState

type TransitGatewayRouteType 

type TransitGatewayRouteType string
const (
	TransitGatewayRouteTypeStatic     TransitGatewayRouteType = "static"
	TransitGatewayRouteTypePropagated TransitGatewayRouteType = "propagated"
)

Enum values for TransitGatewayRouteType

type TransitGatewayState 

type TransitGatewayState string
const (
	TransitGatewayStatePending   TransitGatewayState = "pending"
	TransitGatewayStateAvailable TransitGatewayState = "available"
	TransitGatewayStateModifying TransitGatewayState = "modifying"
	TransitGatewayStateDeleting  TransitGatewayState = "deleting"
	TransitGatewayStateDeleted   TransitGatewayState = "deleted"
)

Enum values for TransitGatewayState

type TransitGatewayVpcAttachment 

type TransitGatewayVpcAttachment struct {
	// The VPC attachment options.
	Options *TransitGatewayVpcAttachmentOptions
	// The IDs of the subnets.
	SubnetIds []*string
	// The ID of the attachment.
	TransitGatewayAttachmentId *string
	// The ID of the AWS account that owns the VPC.
	VpcOwnerId *string
	// The state of the VPC attachment.
	State TransitGatewayAttachmentState
	// The ID of the transit gateway.
	TransitGatewayId *string
	// The tags for the VPC attachment.
	Tags []*Tag
	// The ID of the VPC.
	VpcId *string
	// The creation time.
	CreationTime *time.Time
}

Describes a VPC attachment.

type TransitGatewayVpcAttachmentOptions 

type TransitGatewayVpcAttachmentOptions struct {
	// Indicates whether IPv6 support is disabled.
	Ipv6Support Ipv6SupportValue
	// Indicates whether DNS support is enabled.
	DnsSupport DnsSupportValue
}

Describes the VPC attachment options.

type TransportProtocol 

type TransportProtocol string
const (
	TransportProtocolTcp TransportProtocol = "tcp"
	TransportProtocolUdp TransportProtocol = "udp"
)

Enum values for TransportProtocol

type TunnelOption 

type TunnelOption struct {
	// The number of packets in an IKE replay window.
	ReplayWindowSize *int32
	// The permitted Diffie-Hellman group numbers for the VPN tunnel for phase 2 IKE
	// negotiations.
	Phase2DHGroupNumbers []*Phase2DHGroupNumbersListValue
	// The number of seconds after which a DPD timeout occurs.
	DpdTimeoutSeconds *int32
	// The lifetime for phase 1 of the IKE negotiation, in seconds.
	Phase1LifetimeSeconds *int32
	// The permitted Diffie-Hellman group numbers for the VPN tunnel for phase 1 IKE
	// negotiations.
	Phase1DHGroupNumbers []*Phase1DHGroupNumbersListValue
	// The range of inside IP addresses for the tunnel.
	TunnelInsideCidr *string
	// The IKE versions that are permitted for the VPN tunnel.
	IkeVersions []*IKEVersionsListValue
	// The margin time, in seconds, before the phase 2 lifetime expires, during which
	// the AWS side of the VPN connection performs an IKE rekey.
	RekeyMarginTimeSeconds *int32
	// The permitted encryption algorithms for the VPN tunnel for phase 2 IKE
	// negotiations.
	Phase2EncryptionAlgorithms []*Phase2EncryptionAlgorithmsListValue
	// The lifetime for phase 2 of the IKE negotiation, in seconds.
	Phase2LifetimeSeconds *int32
	// The permitted encryption algorithms for the VPN tunnel for phase 1 IKE
	// negotiations.
	Phase1EncryptionAlgorithms []*Phase1EncryptionAlgorithmsListValue
	// The pre-shared key (PSK) to establish initial authentication between the virtual
	// private gateway and the customer gateway.
	PreSharedKey *string
	// The external IP address of the VPN tunnel.
	OutsideIpAddress *string
	// The permitted integrity algorithms for the VPN tunnel for phase 2 IKE
	// negotiations.
	Phase2IntegrityAlgorithms []*Phase2IntegrityAlgorithmsListValue
	// The permitted integrity algorithms for the VPN tunnel for phase 1 IKE
	// negotiations.
	Phase1IntegrityAlgorithms []*Phase1IntegrityAlgorithmsListValue
	// The percentage of the rekey window determined by RekeyMarginTimeSeconds during
	// which the rekey time is randomly selected.
	RekeyFuzzPercentage *int32
}

The VPN tunnel options.

type UnlimitedSupportedInstanceFamily 

type UnlimitedSupportedInstanceFamily string
const (
	UnlimitedSupportedInstanceFamilyT2  UnlimitedSupportedInstanceFamily = "t2"
	UnlimitedSupportedInstanceFamilyT3  UnlimitedSupportedInstanceFamily = "t3"
	UnlimitedSupportedInstanceFamilyT3a UnlimitedSupportedInstanceFamily = "t3a"
)

Enum values for UnlimitedSupportedInstanceFamily

type UnsuccessfulInstanceCreditSpecificationErrorCode 

type UnsuccessfulInstanceCreditSpecificationErrorCode string
const (
	UnsuccessfulInstanceCreditSpecificationErrorCodeInvalid_instance_id                         UnsuccessfulInstanceCreditSpecificationErrorCode = "InvalidInstanceID.Malformed"
	UnsuccessfulInstanceCreditSpecificationErrorCodeInstance_not_found                          UnsuccessfulInstanceCreditSpecificationErrorCode = "InvalidInstanceID.NotFound"
	UnsuccessfulInstanceCreditSpecificationErrorCodeIncorrect_instance_state                    UnsuccessfulInstanceCreditSpecificationErrorCode = "IncorrectInstanceState"
	UnsuccessfulInstanceCreditSpecificationErrorCodeInstance_credit_specification_not_supported UnsuccessfulInstanceCreditSpecificationErrorCode = "InstanceCreditSpecification.NotSupported"
)

Enum values for UnsuccessfulInstanceCreditSpecificationErrorCode

type UnsuccessfulInstanceCreditSpecificationItem 

type UnsuccessfulInstanceCreditSpecificationItem struct {
	// The applicable error for the burstable performance instance whose credit option
	// for CPU usage was not modified.
	Error *UnsuccessfulInstanceCreditSpecificationItemError
	// The ID of the instance.
	InstanceId *string
}

Describes the burstable performance instance whose credit option for CPU usage was not modified.

type UnsuccessfulInstanceCreditSpecificationItemError 

type UnsuccessfulInstanceCreditSpecificationItemError struct {
	// The error code.
	Code UnsuccessfulInstanceCreditSpecificationErrorCode
	// The applicable error message.
	Message *string
}

Information about the error for the burstable performance instance whose credit option for CPU usage was not modified.

type UnsuccessfulItem 

type UnsuccessfulItem struct {
	// The ID of the resource.
	ResourceId *string
	// Information about the error.
	Error *UnsuccessfulItemError
}

Information about items that were not successfully processed in a batch call.

type UnsuccessfulItemError 

type UnsuccessfulItemError struct {
	// The error code.
	Code *string
	// The error message accompanying the error code.
	Message *string
}

Information about the error that occurred. For more information about errors, see Error Codes (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/errors-overview.html).

type UsageClassType 

type UsageClassType string
const (
	UsageClassTypeSpot     UsageClassType = "spot"
	UsageClassTypeOnDemand UsageClassType = "on-demand"
)

Enum values for UsageClassType

type UserBucket 

type UserBucket struct {
	// The file name of the disk image.
	S3Key *string
	// The name of the Amazon S3 bucket where the disk image is located.
	S3Bucket *string
}

Describes the Amazon S3 bucket for the disk image.

type UserBucketDetails 

type UserBucketDetails struct {
	// The file name of the disk image.
	S3Key *string
	// The Amazon S3 bucket from which the disk image was created.
	S3Bucket *string
}

Describes the Amazon S3 bucket for the disk image.

type UserData 

type UserData struct {
	// The user data. If you are using an AWS SDK or command line tool, Base64-encoding
	// is performed for you, and you can load the text from a file. Otherwise, you must
	// provide Base64-encoded text.
	Data *string
}

Describes the user data for an instance.

type UserIdGroupPair 

type UserIdGroupPair struct {
	// The ID of the security group.
	GroupId *string
	// The ID of the VPC for the referenced security group, if applicable.
	VpcId *string
	// The status of a VPC peering connection, if applicable.
	PeeringStatus *string
	// A description for the security group rule that references this user ID group
	// pair. Constraints: Up to 255 characters in length. Allowed characters are a-z,
	// A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*
	Description *string
	// The ID of the VPC peering connection, if applicable.
	VpcPeeringConnectionId *string
	// The name of the security group. In a request, use this parameter for a security
	// group in EC2-Classic or a default VPC only. For a security group in a nondefault
	// VPC, use the security group ID. For a referenced security group in another VPC,
	// this value is not returned if the referenced security group is deleted.
	GroupName *string
	// The ID of an AWS account. For a referenced security group in another VPC, the
	// account ID of the referenced security group is returned in the response. If the
	// referenced security group is deleted, this value is not returned. [EC2-Classic]
	// Required when adding or removing rules that reference a security group in
	// another AWS account.
	UserId *string
}

Describes a security group and AWS account ID pair.

type VCpuInfo 

type VCpuInfo struct {
	// The default number of vCPUs for the instance type.
	DefaultVCpus *int32
	// The default number of threads per core for the instance type.
	DefaultThreadsPerCore *int32
	// List of the valid number of cores that can be configured for the instance type.
	ValidCores []*int32
	// The default number of cores for the instance type.
	DefaultCores *int32
	// List of the valid number of threads per core that can be configured for the
	// instance type.
	ValidThreadsPerCore []*int32
}

Describes the vCPU configurations for the instance type.

type ValidationError 

type ValidationError struct {
	// The error code that indicates why the parameter or parameter combination is not
	// valid. For more information about error codes, see Error Codes
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/errors-overview.html.html).
	Code *string
	// The error message that describes why the parameter or parameter combination is
	// not valid. For more information about error messages, see Error Codes
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/errors-overview.html.html).
	Message *string
}

The error code and error message that is returned for a parameter or parameter combination that is not valid when a new launch template or new version of a launch template is created.

type ValidationWarning 

type ValidationWarning struct {
	// The error codes and error messages.
	Errors []*ValidationError
}

The error codes and error messages that are returned for the parameters or parameter combinations that are not valid when a new launch template or new version of a launch template is created.

type VgwTelemetry 

type VgwTelemetry struct {
	// The number of accepted routes.
	AcceptedRouteCount *int32
	// The date and time of the last change in status.
	LastStatusChange *time.Time
	// The Amazon Resource Name (ARN) of the VPN tunnel endpoint certificate.
	CertificateArn *string
	// The Internet-routable IP address of the virtual private gateway's outside
	// interface.
	OutsideIpAddress *string
	// If an error occurs, a description of the error.
	StatusMessage *string
	// The status of the VPN tunnel.
	Status TelemetryStatus
}

Describes telemetry for a VPN tunnel.

type VirtualizationType 

type VirtualizationType string
const (
	VirtualizationTypeHvm         VirtualizationType = "hvm"
	VirtualizationTypeParavirtual VirtualizationType = "paravirtual"
)

Enum values for VirtualizationType

type Volume 

type Volume struct {
	// Indicates whether the volume is encrypted.
	Encrypted *bool
	// Any tags assigned to the volume.
	Tags []*Tag
	// Indicates whether Amazon EBS Multi-Attach is enabled.
	MultiAttachEnabled *bool
	// The Amazon Resource Name (ARN) of the Outpost.
	OutpostArn *string
	// The size of the volume, in GiBs.
	Size *int32
	// The volume type. This can be gp2 for General Purpose SSD, io1 for Provisioned
	// IOPS SSD, st1 for Throughput Optimized HDD, sc1 for Cold HDD, or standard for
	// Magnetic volumes.
	VolumeType VolumeType
	// Indicates whether the volume was created using fast snapshot restore.
	FastRestored *bool
	// Information about the volume attachments.
	Attachments []*VolumeAttachment
	// The snapshot from which the volume was created, if applicable.
	SnapshotId *string
	// The volume state.
	State VolumeState
	// The Amazon Resource Name (ARN) of the AWS Key Management Service (AWS KMS)
	// customer master key (CMK) that was used to protect the volume encryption key for
	// the volume.
	KmsKeyId *string
	// The Availability Zone for the volume.
	AvailabilityZone *string
	// The time stamp when volume creation was initiated.
	CreateTime *time.Time
	// The ID of the volume.
	VolumeId *string
	// The number of I/O operations per second (IOPS) that the volume supports. For
	// Provisioned IOPS SSD volumes, this represents the number of IOPS that are
	// provisioned for the volume. For General Purpose SSD volumes, this represents the
	// baseline performance of the volume and the rate at which the volume accumulates
	// I/O credits for bursting. For more information, see Amazon EBS Volume Types
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html) in the
	// Amazon Elastic Compute Cloud User Guide. Constraints: Range is 100-16,000 IOPS
	// for gp2 volumes and 100 to 64,000IOPS for io1 volumes, in most Regions. The
	// maximum IOPS for io1 of 64,000 is guaranteed only on Nitro-based instances
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances).
	// Other instance families guarantee performance up to 32,000 IOPS. Condition: This
	// parameter is required for requests to create io1 volumes; it is not used in
	// requests to create gp2, st1, sc1, or standard volumes.
	Iops *int32
}

Describes a volume.

type VolumeAttachment 

type VolumeAttachment struct {
	// The ID of the volume.
	VolumeId *string
	// The ID of the instance.
	InstanceId *string
	// The time stamp when the attachment initiated.
	AttachTime *time.Time
	// The device name.
	Device *string
	// Indicates whether the EBS volume is deleted on instance termination.
	DeleteOnTermination *bool
	// The attachment state of the volume.
	State VolumeAttachmentState
}

Describes volume attachment details.

type VolumeAttachmentState 

type VolumeAttachmentState string
const (
	VolumeAttachmentStateAttaching VolumeAttachmentState = "attaching"
	VolumeAttachmentStateAttached  VolumeAttachmentState = "attached"
	VolumeAttachmentStateDetaching VolumeAttachmentState = "detaching"
	VolumeAttachmentStateDetached  VolumeAttachmentState = "detached"
	VolumeAttachmentStateBusy      VolumeAttachmentState = "busy"
)

Enum values for VolumeAttachmentState

type VolumeAttributeName 

type VolumeAttributeName string
const (
	VolumeAttributeNameAutoenableio VolumeAttributeName = "autoEnableIO"
	VolumeAttributeNameProductcodes VolumeAttributeName = "productCodes"
)

Enum values for VolumeAttributeName

type VolumeDetail 

type VolumeDetail struct {
	// The size of the volume, in GiB.
	Size *int64
}

Describes an EBS volume.

type VolumeModification 

type VolumeModification struct {
	// The original IOPS rate of the volume.
	OriginalIops *int32
	// The current modification state. The modification state is null for unmodified
	// volumes.
	ModificationState VolumeModificationState
	// The target EBS volume type of the volume.
	TargetVolumeType VolumeType
	// The target size of the volume, in GiB.
	TargetSize *int32
	// The original size of the volume, in GiB.
	OriginalSize *int32
	// The original EBS volume type of the volume.
	OriginalVolumeType VolumeType
	// The modification completion or failure time.
	EndTime *time.Time
	// The ID of the volume.
	VolumeId *string
	// The modification progress, from 0 to 100 percent complete.
	Progress *int64
	// A status message about the modification progress or failure.
	StatusMessage *string
	// The target IOPS rate of the volume.
	TargetIops *int32
	// The modification start time.
	StartTime *time.Time
}

Describes the modification status of an EBS volume. If the volume has never been modified, some element values will be null.

type VolumeModificationState 

type VolumeModificationState string
const (
	VolumeModificationStateModifying  VolumeModificationState = "modifying"
	VolumeModificationStateOptimizing VolumeModificationState = "optimizing"
	VolumeModificationStateCompleted  VolumeModificationState = "completed"
	VolumeModificationStateFailed     VolumeModificationState = "failed"
)

Enum values for VolumeModificationState

type VolumeState 

type VolumeState string
const (
	VolumeStateCreating  VolumeState = "creating"
	VolumeStateAvailable VolumeState = "available"
	VolumeStateInUse     VolumeState = "in-use"
	VolumeStateDeleting  VolumeState = "deleting"
	VolumeStateDeleted   VolumeState = "deleted"
	VolumeStateError     VolumeState = "error"
)

Enum values for VolumeState

type VolumeStatusAction 

type VolumeStatusAction struct {
	// The event type associated with this operation.
	EventType *string
	// A description of the operation.
	Description *string
	// The code identifying the operation, for example, enable-volume-io.
	Code *string
	// The ID of the event associated with this operation.
	EventId *string
}

Describes a volume status operation code.

type VolumeStatusAttachmentStatus 

type VolumeStatusAttachmentStatus struct {
	// The ID of the attached instance.
	InstanceId *string
	// The maximum IOPS supported by the attached instance.
	IoPerformance *string
}

Information about the instances to which the volume is attached.

type VolumeStatusDetails 

type VolumeStatusDetails struct {
	// The intended status of the volume status.
	Status *string
	// The name of the volume status.
	Name VolumeStatusName
}

Describes a volume status.

type VolumeStatusEvent 

type VolumeStatusEvent struct {
	// The ID of this event.
	EventId *string
	// The earliest start time of the event.
	NotBefore *time.Time
	// A description of the event.
	Description *string
	// The ID of the instance associated with the event.
	InstanceId *string
	// The type of this event.
	EventType *string
	// The latest end time of the event.
	NotAfter *time.Time
}

Describes a volume status event.

type VolumeStatusInfo 

type VolumeStatusInfo struct {
	// The details of the volume status.
	Details []*VolumeStatusDetails
	// The status of the volume.
	Status VolumeStatusInfoStatus
}

Describes the status of a volume.

type VolumeStatusInfoStatus 

type VolumeStatusInfoStatus string
const (
	VolumeStatusInfoStatusOk               VolumeStatusInfoStatus = "ok"
	VolumeStatusInfoStatusImpaired         VolumeStatusInfoStatus = "impaired"
	VolumeStatusInfoStatusInsufficientData VolumeStatusInfoStatus = "insufficient-data"
)

Enum values for VolumeStatusInfoStatus

type VolumeStatusItem 

type VolumeStatusItem struct {
	// The Availability Zone of the volume.
	AvailabilityZone *string
	// Information about the instances to which the volume is attached.
	AttachmentStatuses []*VolumeStatusAttachmentStatus
	// The volume status.
	VolumeStatus *VolumeStatusInfo
	// The Amazon Resource Name (ARN) of the Outpost.
	OutpostArn *string
	// The volume ID.
	VolumeId *string
	// A list of events associated with the volume.
	Events []*VolumeStatusEvent
	// The details of the operation.
	Actions []*VolumeStatusAction
}

Describes the volume status.

type VolumeStatusName 

type VolumeStatusName string
const (
	VolumeStatusNameIoEnabled     VolumeStatusName = "io-enabled"
	VolumeStatusNameIoPerformance VolumeStatusName = "io-performance"
)

Enum values for VolumeStatusName

type VolumeType 

type VolumeType string
const (
	VolumeTypeStandard VolumeType = "standard"
	VolumeTypeIo1      VolumeType = "io1"
	VolumeTypeGp2      VolumeType = "gp2"
	VolumeTypeSc1      VolumeType = "sc1"
	VolumeTypeSt1      VolumeType = "st1"
)

Enum values for VolumeType

type Vpc 

type Vpc struct {
	// The ID of the AWS account that owns the VPC.
	OwnerId *string
	// The ID of the set of DHCP options you've associated with the VPC (or default if
	// the default options are associated with the VPC).
	DhcpOptionsId *string
	// The primary IPv4 CIDR block for the VPC.
	CidrBlock *string
	// The current state of the VPC.
	State VpcState
	// Indicates whether the VPC is the default VPC.
	IsDefault *bool
	// The ID of the VPC.
	VpcId *string
	// Information about the IPv4 CIDR blocks associated with the VPC.
	CidrBlockAssociationSet []*VpcCidrBlockAssociation
	// Any tags assigned to the VPC.
	Tags []*Tag
	// Information about the IPv6 CIDR blocks associated with the VPC.
	Ipv6CidrBlockAssociationSet []*VpcIpv6CidrBlockAssociation
	// The allowed tenancy of instances launched into the VPC.
	InstanceTenancy Tenancy
}

Describes a VPC.

type VpcAttachment 

type VpcAttachment struct {
	// The current state of the attachment.
	State AttachmentStatus
	// The ID of the VPC.
	VpcId *string
}

Describes an attachment between a virtual private gateway and a VPC.

type VpcAttributeName 

type VpcAttributeName string
const (
	VpcAttributeNameEnablednssupport   VpcAttributeName = "enableDnsSupport"
	VpcAttributeNameEnablednshostnames VpcAttributeName = "enableDnsHostnames"
)

Enum values for VpcAttributeName

type VpcCidrBlockAssociation 

type VpcCidrBlockAssociation struct {
	// Information about the state of the CIDR block.
	CidrBlockState *VpcCidrBlockState
	// The association ID for the IPv4 CIDR block.
	AssociationId *string
	// The IPv4 CIDR block.
	CidrBlock *string
}

Describes an IPv4 CIDR block associated with a VPC.

type VpcCidrBlockState 

type VpcCidrBlockState struct {
	// A message about the status of the CIDR block, if applicable.
	StatusMessage *string
	// The state of the CIDR block.
	State VpcCidrBlockStateCode
}

Describes the state of a CIDR block.

type VpcCidrBlockStateCode 

type VpcCidrBlockStateCode string
const (
	VpcCidrBlockStateCodeAssociating    VpcCidrBlockStateCode = "associating"
	VpcCidrBlockStateCodeAssociated     VpcCidrBlockStateCode = "associated"
	VpcCidrBlockStateCodeDisassociating VpcCidrBlockStateCode = "disassociating"
	VpcCidrBlockStateCodeDisassociated  VpcCidrBlockStateCode = "disassociated"
	VpcCidrBlockStateCodeFailing        VpcCidrBlockStateCode = "failing"
	VpcCidrBlockStateCodeFailed         VpcCidrBlockStateCode = "failed"
)

Enum values for VpcCidrBlockStateCode 

type VpcClassicLink struct {
	// The ID of the VPC.
	VpcId *string
	// Indicates whether the VPC is enabled for ClassicLink.
	ClassicLinkEnabled *bool
	// Any tags assigned to the VPC.
	Tags []*Tag
}

Describes whether a VPC is enabled for ClassicLink.

type VpcEndpoint 

type VpcEndpoint struct {
	// The last error that occurred for VPC endpoint.
	LastError *LastError
	// The policy document associated with the endpoint, if applicable.
	PolicyDocument *string
	// The ID of the VPC endpoint.
	VpcEndpointId *string
	// Any tags assigned to the VPC endpoint.
	Tags []*Tag
	// (Interface endpoint) One or more network interfaces for the endpoint.
	NetworkInterfaceIds []*string
	// (Interface endpoint) One or more subnets in which the endpoint is located.
	SubnetIds []*string
	// The type of endpoint.
	VpcEndpointType VpcEndpointType
	// The date and time that the VPC endpoint was created.
	CreationTimestamp *time.Time
	// (Interface endpoint) The DNS entries for the endpoint.
	DnsEntries []*DnsEntry
	// (Gateway endpoint) One or more route tables associated with the endpoint.
	RouteTableIds []*string
	// The name of the service to which the endpoint is associated.
	ServiceName *string
	// The ID of the AWS account that owns the VPC endpoint.
	OwnerId *string
	// (Interface endpoint) Information about the security groups that are associated
	// with the network interface.
	Groups []*SecurityGroupIdentifier
	// The state of the VPC endpoint.
	State State
	// Indicates whether the VPC endpoint is being managed by its service.
	RequesterManaged *bool
	// (Interface endpoint) Indicates whether the VPC is associated with a private
	// hosted zone.
	PrivateDnsEnabled *bool
	// The ID of the VPC to which the endpoint is associated.
	VpcId *string
}

Describes a VPC endpoint.

type VpcEndpointConnection 

type VpcEndpointConnection struct {
	// The ID of the VPC endpoint.
	VpcEndpointId *string
	// The state of the VPC endpoint.
	VpcEndpointState State
	// The AWS account ID of the owner of the VPC endpoint.
	VpcEndpointOwner *string
	// The ID of the service to which the endpoint is connected.
	ServiceId *string
	// The Amazon Resource Names (ARNs) of the network load balancers for the service.
	NetworkLoadBalancerArns []*string
	// The DNS entries for the VPC endpoint.
	DnsEntries []*DnsEntry
	// The date and time that the VPC endpoint was created.
	CreationTimestamp *time.Time
}

Describes a VPC endpoint connection to a service.

type VpcEndpointType 

type VpcEndpointType string
const (
	VpcEndpointTypeInterface VpcEndpointType = "Interface"
	VpcEndpointTypeGateway   VpcEndpointType = "Gateway"
)

Enum values for VpcEndpointType

type VpcIpv6CidrBlockAssociation 

type VpcIpv6CidrBlockAssociation struct {
	// The name of the location from which we advertise the IPV6 CIDR block.
	NetworkBorderGroup *string
	// The association ID for the IPv6 CIDR block.
	AssociationId *string
	// The IPv6 CIDR block.
	Ipv6CidrBlock *string
	// The ID of the IPv6 address pool from which the IPv6 CIDR block is allocated.
	Ipv6Pool *string
	// Information about the state of the CIDR block.
	Ipv6CidrBlockState *VpcCidrBlockState
}

Describes an IPv6 CIDR block associated with a VPC.

type VpcPeeringConnection 

type VpcPeeringConnection struct {
	// Information about the accepter VPC. CIDR block information is only returned when
	// describing an active VPC peering connection.
	AccepterVpcInfo *VpcPeeringConnectionVpcInfo
	// Information about the requester VPC. CIDR block information is only returned
	// when describing an active VPC peering connection.
	RequesterVpcInfo *VpcPeeringConnectionVpcInfo
	// Any tags assigned to the resource.
	Tags []*Tag
	// The status of the VPC peering connection.
	Status *VpcPeeringConnectionStateReason
	// The ID of the VPC peering connection.
	VpcPeeringConnectionId *string
	// The time that an unaccepted VPC peering connection will expire.
	ExpirationTime *time.Time
}

Describes a VPC peering connection.

type VpcPeeringConnectionOptionsDescription 

type VpcPeeringConnectionOptionsDescription struct {
	// Indicates whether a local VPC can communicate with a ClassicLink connection in
	// the peer VPC over the VPC peering connection.
	AllowEgressFromLocalVpcToRemoteClassicLink *bool
	// Indicates whether a local VPC can resolve public DNS hostnames to private IP
	// addresses when queried from instances in a peer VPC.
	AllowDnsResolutionFromRemoteVpc *bool
	// Indicates whether a local ClassicLink connection can communicate with the peer
	// VPC over the VPC peering connection.
	AllowEgressFromLocalClassicLinkToRemoteVpc *bool
}

Describes the VPC peering connection options.

type VpcPeeringConnectionStateReason 

type VpcPeeringConnectionStateReason struct {
	// A message that provides more information about the status, if applicable.
	Message *string
	// The status of the VPC peering connection.
	Code VpcPeeringConnectionStateReasonCode
}

Describes the status of a VPC peering connection.

type VpcPeeringConnectionStateReasonCode 

type VpcPeeringConnectionStateReasonCode string
const (
	VpcPeeringConnectionStateReasonCodeInitiatingRequest VpcPeeringConnectionStateReasonCode = "initiating-request"
	VpcPeeringConnectionStateReasonCodePendingAcceptance VpcPeeringConnectionStateReasonCode = "pending-acceptance"
	VpcPeeringConnectionStateReasonCodeActive            VpcPeeringConnectionStateReasonCode = "active"
	VpcPeeringConnectionStateReasonCodeDeleted           VpcPeeringConnectionStateReasonCode = "deleted"
	VpcPeeringConnectionStateReasonCodeRejected          VpcPeeringConnectionStateReasonCode = "rejected"
	VpcPeeringConnectionStateReasonCodeFailed            VpcPeeringConnectionStateReasonCode = "failed"
	VpcPeeringConnectionStateReasonCodeExpired           VpcPeeringConnectionStateReasonCode = "expired"
	VpcPeeringConnectionStateReasonCodeProvisioning      VpcPeeringConnectionStateReasonCode = "provisioning"
	VpcPeeringConnectionStateReasonCodeDeleting          VpcPeeringConnectionStateReasonCode = "deleting"
)

Enum values for VpcPeeringConnectionStateReasonCode

type VpcPeeringConnectionVpcInfo 

type VpcPeeringConnectionVpcInfo struct {
	// The Region in which the VPC is located.
	Region *string
	// The IPv6 CIDR block for the VPC.
	Ipv6CidrBlockSet []*Ipv6CidrBlock
	// The IPv4 CIDR block for the VPC.
	CidrBlock *string
	// The ID of the VPC.
	VpcId *string
	// Information about the VPC peering connection options for the accepter or
	// requester VPC.
	PeeringOptions *VpcPeeringConnectionOptionsDescription
	// Information about the IPv4 CIDR blocks for the VPC.
	CidrBlockSet []*CidrBlock
	// The AWS account ID of the VPC owner.
	OwnerId *string
}

Describes a VPC in a VPC peering connection.

type VpcState 

type VpcState string
const (
	VpcStatePending   VpcState = "pending"
	VpcStateAvailable VpcState = "available"
)

Enum values for VpcState

type VpcTenancy 

type VpcTenancy string
const (
	VpcTenancyDefault VpcTenancy = "default"
)

Enum values for VpcTenancy

type VpnConnection 

type VpnConnection struct {
	// The type of VPN connection.
	Type GatewayType
	// The ID of the virtual private gateway at the AWS side of the VPN connection.
	VpnGatewayId *string
	// Information about the VPN tunnel.
	VgwTelemetry []*VgwTelemetry
	// The ID of the customer gateway at your end of the VPN connection.
	CustomerGatewayId *string
	// The ID of the transit gateway associated with the VPN connection.
	TransitGatewayId *string
	// The static routes associated with the VPN connection.
	Routes []*VpnStaticRoute
	// The VPN connection options.
	Options *VpnConnectionOptions
	// The ID of the VPN connection.
	VpnConnectionId *string
	// The configuration information for the VPN connection's customer gateway (in the
	// native XML format). This element is always present in the CreateVpnConnection ()
	// response; however, it's present in the DescribeVpnConnections () response only
	// if the VPN connection is in the pending or available state.
	CustomerGatewayConfiguration *string
	// The current state of the VPN connection.
	State VpnState
	// The category of the VPN connection. A value of VPN indicates an AWS VPN
	// connection. A value of VPN-Classic indicates an AWS Classic VPN connection.
	Category *string
	// Any tags assigned to the VPN connection.
	Tags []*Tag
}

Describes a VPN connection.

type VpnConnectionOptions 

type VpnConnectionOptions struct {
	// Indicates whether acceleration is enabled for the VPN connection.
	EnableAcceleration *bool
	// Indicates the VPN tunnel options.
	TunnelOptions []*TunnelOption
	// Indicates whether the VPN connection uses static routes only. Static routes must
	// be used for devices that don't support BGP.
	StaticRoutesOnly *bool
}

Describes VPN connection options.

type VpnConnectionOptionsSpecification 

type VpnConnectionOptionsSpecification struct {
	// The tunnel options for the VPN connection.
	TunnelOptions []*VpnTunnelOptionsSpecification
	// Indicate whether the VPN connection uses static routes only. If you are creating
	// a VPN connection for a device that does not support BGP, you must specify true.
	// Use CreateVpnConnectionRoute () to create a static route. Default: false
	StaticRoutesOnly *bool
	// Indicate whether to enable acceleration for the VPN connection. Default: false
	EnableAcceleration *bool
}

Describes VPN connection options.

type VpnEcmpSupportValue 

type VpnEcmpSupportValue string
const (
	VpnEcmpSupportValueEnable  VpnEcmpSupportValue = "enable"
	VpnEcmpSupportValueDisable VpnEcmpSupportValue = "disable"
)

Enum values for VpnEcmpSupportValue

type VpnGateway 

type VpnGateway struct {
	// The ID of the virtual private gateway.
	VpnGatewayId *string
	// The current state of the virtual private gateway.
	State VpnState
	// Any tags assigned to the virtual private gateway.
	Tags []*Tag
	// Any VPCs attached to the virtual private gateway.
	VpcAttachments []*VpcAttachment
	// The private Autonomous System Number (ASN) for the Amazon side of a BGP session.
	AmazonSideAsn *int64
	// The type of VPN connection the virtual private gateway supports.
	Type GatewayType
	// The Availability Zone where the virtual private gateway was created, if
	// applicable. This field may be empty or not returned.
	AvailabilityZone *string
}

Describes a virtual private gateway.

type VpnProtocol 

type VpnProtocol string
const (
	VpnProtocolOpenvpn VpnProtocol = "openvpn"
)

Enum values for VpnProtocol

type VpnState 

type VpnState string
const (
	VpnStatePending   VpnState = "pending"
	VpnStateAvailable VpnState = "available"
	VpnStateDeleting  VpnState = "deleting"
	VpnStateDeleted   VpnState = "deleted"
)

Enum values for VpnState

type VpnStaticRoute 

type VpnStaticRoute struct {
	// Indicates how the routes were provided.
	Source VpnStaticRouteSource
	// The current state of the static route.
	State VpnState
	// The CIDR block associated with the local subnet of the customer data center.
	DestinationCidrBlock *string
}

Describes a static route for a VPN connection.

type VpnStaticRouteSource 

type VpnStaticRouteSource string
const (
	VpnStaticRouteSourceStatic VpnStaticRouteSource = "Static"
)

Enum values for VpnStaticRouteSource

type VpnTunnelOptionsSpecification 

type VpnTunnelOptionsSpecification struct {
	// The margin time, in seconds, before the phase 2 lifetime expires, during which
	// the AWS side of the VPN connection performs an IKE rekey. The exact time of the
	// rekey is randomly selected based on the value for RekeyFuzzPercentage.
	// Constraints: A value between 60 and half of Phase2LifetimeSeconds. Default: 540
	RekeyMarginTimeSeconds *int32
	// The lifetime for phase 2 of the IKE negotiation, in seconds. Constraints: A
	// value between 900 and 3,600. The value must be less than the value for
	// Phase1LifetimeSeconds. Default: 3600
	Phase2LifetimeSeconds *int32
	// One or more integrity algorithms that are permitted for the VPN tunnel for phase
	// 2 IKE negotiations. Valid values: SHA1 | SHA2-256
	Phase2IntegrityAlgorithms []*Phase2IntegrityAlgorithmsRequestListValue
	// The pre-shared key (PSK) to establish initial authentication between the virtual
	// private gateway and customer gateway. Constraints: Allowed characters are
	// alphanumeric characters, periods (.), and underscores (_). Must be between 8 and
	// 64 characters in length and cannot start with zero (0).
	PreSharedKey *string
	// One or more integrity algorithms that are permitted for the VPN tunnel for phase
	// 1 IKE negotiations. Valid values: SHA1 | SHA2-256
	Phase1IntegrityAlgorithms []*Phase1IntegrityAlgorithmsRequestListValue
	// The IKE versions that are permitted for the VPN tunnel. Valid values: ikev1 |
	// ikev2
	IKEVersions []*IKEVersionsRequestListValue
	// The range of inside IP addresses for the tunnel. Any specified CIDR blocks must
	// be unique across all VPN connections that use the same virtual private gateway.
	// Constraints: A size /30 CIDR block from the 169.254.0.0/16 range. The following
	// CIDR blocks are reserved and cannot be used:
	//
	//     * 169.254.0.0/30
	//
	//     *
	// 169.254.1.0/30
	//
	//     * 169.254.2.0/30
	//
	//     * 169.254.3.0/30
	//
	//     *
	// 169.254.4.0/30
	//
	//     * 169.254.5.0/30
	//
	//     * 169.254.169.252/30
	TunnelInsideCidr *string
	// One or more Diffie-Hellman group numbers that are permitted for the VPN tunnel
	// for phase 1 IKE negotiations. Valid values: 2 | 14 | 15 | 16 | 17 | 18 | 22 | 23
	// | 24
	Phase1DHGroupNumbers []*Phase1DHGroupNumbersRequestListValue
	// The number of packets in an IKE replay window. Constraints: A value between 64
	// and 2048. Default: 1024
	ReplayWindowSize *int32
	// One or more encryption algorithms that are permitted for the VPN tunnel for
	// phase 2 IKE negotiations. Valid values: AES128 | AES256
	Phase2EncryptionAlgorithms []*Phase2EncryptionAlgorithmsRequestListValue
	// One or more Diffie-Hellman group numbers that are permitted for the VPN tunnel
	// for phase 2 IKE negotiations. Valid values: 2 | 5 | 14 | 15 | 16 | 17 | 18 | 22
	// | 23 | 24
	Phase2DHGroupNumbers []*Phase2DHGroupNumbersRequestListValue
	// The percentage of the rekey window (determined by RekeyMarginTimeSeconds) during
	// which the rekey time is randomly selected. Constraints: A value between 0 and
	// 100. Default: 100
	RekeyFuzzPercentage *int32
	// The lifetime for phase 1 of the IKE negotiation, in seconds. Constraints: A
	// value between 900 and 28,800. Default: 28800
	Phase1LifetimeSeconds *int32
	// One or more encryption algorithms that are permitted for the VPN tunnel for
	// phase 1 IKE negotiations. Valid values: AES128 | AES256
	Phase1EncryptionAlgorithms []*Phase1EncryptionAlgorithmsRequestListValue
	// The number of seconds after which a DPD timeout occurs. Constraints: A value
	// between 0 and 30. Default: 30
	DPDTimeoutSeconds *int32
}

The tunnel options for a single VPN tunnel.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.