Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException

type AccessDeniedException struct {
	Message *string

	Code *string
	Docs *string
	Tip  *string
}

    Lightsail throws this exception when the user cannot be authenticated or uses invalid credentials to access a resource.

    func (*AccessDeniedException) Error

    func (e *AccessDeniedException) Error() string

    func (*AccessDeniedException) ErrorCode

    func (e *AccessDeniedException) ErrorCode() string

    func (*AccessDeniedException) ErrorFault

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

    func (*AccessDeniedException) ErrorMessage

    func (e *AccessDeniedException) ErrorMessage() string

    type AccessDirection

    type AccessDirection string
    const (
    	AccessDirectionInbound  AccessDirection = "inbound"
    	AccessDirectionOutbound AccessDirection = "outbound"
    )

      Enum values for AccessDirection

      func (AccessDirection) Values

      func (AccessDirection) Values() []AccessDirection

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

        type AccountSetupInProgressException

        type AccountSetupInProgressException struct {
        	Message *string
        
        	Code *string
        	Docs *string
        	Tip  *string
        }

          Lightsail throws this exception when an account is still in the setup in progress state.

          func (*AccountSetupInProgressException) Error

          func (*AccountSetupInProgressException) ErrorCode

          func (e *AccountSetupInProgressException) ErrorCode() string

          func (*AccountSetupInProgressException) ErrorFault

          func (*AccountSetupInProgressException) ErrorMessage

          func (e *AccountSetupInProgressException) ErrorMessage() string

          type AddOn

          type AddOn struct {
          
          	// The name of the add-on.
          	Name *string
          
          	// The next daily time an automatic snapshot will be created. The time shown is in
          	// HH:00 format, and in Coordinated Universal Time (UTC). The snapshot is
          	// automatically created between the time shown and up to 45 minutes after.
          	NextSnapshotTimeOfDay *string
          
          	// The daily time when an automatic snapshot is created. The time shown is in HH:00
          	// format, and in Coordinated Universal Time (UTC). The snapshot is automatically
          	// created between the time shown and up to 45 minutes after.
          	SnapshotTimeOfDay *string
          
          	// The status of the add-on.
          	Status *string
          }

            Describes an add-on that is enabled for an Amazon Lightsail resource.

            type AddOnRequest

            type AddOnRequest struct {
            
            	// The add-on type.
            	//
            	// This member is required.
            	AddOnType AddOnType
            
            	// An object that represents additional parameters when enabling or modifying the
            	// automatic snapshot add-on.
            	AutoSnapshotAddOnRequest *AutoSnapshotAddOnRequest
            }

              Describes a request to enable, modify, or disable an add-on for an Amazon Lightsail resource. An additional cost may be associated with enabling add-ons. For more information, see the Lightsail pricing page (https://aws.amazon.com/lightsail/pricing/).

              type AddOnType

              type AddOnType string
              const (
              	AddOnTypeAutoSnapshot AddOnType = "AutoSnapshot"
              )

                Enum values for AddOnType

                func (AddOnType) Values

                func (AddOnType) Values() []AddOnType

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

                  type Alarm

                  type Alarm struct {
                  
                  	// The Amazon Resource Name (ARN) of the alarm.
                  	Arn *string
                  
                  	// The arithmetic operation used when comparing the specified statistic and
                  	// threshold.
                  	ComparisonOperator ComparisonOperator
                  
                  	// The contact protocols for the alarm, such as Email, SMS (text messaging), or
                  	// both.
                  	ContactProtocols []ContactProtocol
                  
                  	// The timestamp when the alarm was created.
                  	CreatedAt *time.Time
                  
                  	// The number of data points that must not within the specified threshold to
                  	// trigger the alarm.
                  	DatapointsToAlarm *int32
                  
                  	// The number of periods over which data is compared to the specified threshold.
                  	EvaluationPeriods *int32
                  
                  	// An object that lists information about the location of the alarm.
                  	Location *ResourceLocation
                  
                  	// The name of the metric associated with the alarm.
                  	MetricName MetricName
                  
                  	// An object that lists information about the resource monitored by the alarm.
                  	MonitoredResourceInfo *MonitoredResourceInfo
                  
                  	// The name of the alarm.
                  	Name *string
                  
                  	// Indicates whether the alarm is enabled.
                  	NotificationEnabled *bool
                  
                  	// The alarm states that trigger a notification.
                  	NotificationTriggers []AlarmState
                  
                  	// The period, in seconds, over which the statistic is applied.
                  	Period int32
                  
                  	// The Lightsail resource type (e.g., Alarm).
                  	ResourceType ResourceType
                  
                  	// The current state of the alarm. An alarm has the following possible states:
                  	//
                  	// *
                  	// ALARM - The metric is outside of the defined threshold.
                  	//
                  	// * INSUFFICIENT_DATA -
                  	// The alarm has just started, the metric is not available, or not enough data is
                  	// available for the metric to determine the alarm state.
                  	//
                  	// * OK - The metric is
                  	// within the defined threshold.
                  	State AlarmState
                  
                  	// The statistic for the metric associated with the alarm. The following statistics
                  	// are available:
                  	//
                  	// * Minimum - The lowest value observed during the specified
                  	// period. Use this value to determine low volumes of activity for your
                  	// application.
                  	//
                  	// * Maximum - The highest value observed during the specified
                  	// period. Use this value to determine high volumes of activity for your
                  	// application.
                  	//
                  	// * Sum - All values submitted for the matching metric added
                  	// together. You can use this statistic to determine the total volume of a
                  	// metric.
                  	//
                  	// * Average - The value of Sum / SampleCount during the specified period.
                  	// By comparing this statistic with the Minimum and Maximum values, you can
                  	// determine the full scope of a metric and how close the average use is to the
                  	// Minimum and Maximum values. This comparison helps you to know when to increase
                  	// or decrease your resources.
                  	//
                  	// * SampleCount - The count, or number, of data
                  	// points used for the statistical calculation.
                  	Statistic MetricStatistic
                  
                  	// The support code. Include this code in your email to support when you have
                  	// questions about your Lightsail alarm. This code enables our support team to look
                  	// up your Lightsail information more easily.
                  	SupportCode *string
                  
                  	// The value against which the specified statistic is compared.
                  	Threshold *float64
                  
                  	// Specifies how the alarm handles missing data points. An alarm can treat missing
                  	// data in the following ways:
                  	//
                  	// * breaching - Assume the missing data is not within
                  	// the threshold. Missing data counts towards the number of times the metric is not
                  	// within the threshold.
                  	//
                  	// * notBreaching - Assume the missing data is within the
                  	// threshold. Missing data does not count towards the number of times the metric is
                  	// not within the threshold.
                  	//
                  	// * ignore - Ignore the missing data. Maintains the
                  	// current alarm state.
                  	//
                  	// * missing - Missing data is treated as missing.
                  	TreatMissingData TreatMissingData
                  
                  	// The unit of the metric associated with the alarm.
                  	Unit MetricUnit
                  }

                    Describes an alarm. An alarm is a way to monitor your Amazon Lightsail resource metrics. For more information, see Alarms in Amazon Lightsail (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-alarms).

                    type AlarmState

                    type AlarmState string
                    const (
                    	AlarmStateOk               AlarmState = "OK"
                    	AlarmStateAlarm            AlarmState = "ALARM"
                    	AlarmStateInsufficientData AlarmState = "INSUFFICIENT_DATA"
                    )

                      Enum values for AlarmState

                      func (AlarmState) Values

                      func (AlarmState) Values() []AlarmState

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

                        type AttachedDisk

                        type AttachedDisk struct {
                        
                        	// The path of the disk (e.g., /dev/xvdf).
                        	Path *string
                        
                        	// The size of the disk in GB.
                        	SizeInGb *int32
                        }

                          Describes a block storage disk that is attached to an instance, and is included in an automatic snapshot.

                          type AutoSnapshotAddOnRequest

                          type AutoSnapshotAddOnRequest struct {
                          
                          	// The daily time when an automatic snapshot will be created. Constraints:
                          	//
                          	// * Must
                          	// be in HH:00 format, and in an hourly increment.
                          	//
                          	// * Specified in Coordinated
                          	// Universal Time (UTC).
                          	//
                          	// * The snapshot will be automatically created between the
                          	// time specified and up to 45 minutes after.
                          	SnapshotTimeOfDay *string
                          }

                            Describes a request to enable or modify the automatic snapshot add-on for an Amazon Lightsail instance or disk. When you modify the automatic snapshot time for a resource, it is typically effective immediately except under the following conditions:

                            * If an automatic snapshot has been created for the current day, and you change the snapshot time to a later time of day, then the new snapshot time will be effective the following day. This ensures that two snapshots are not created for the current day.

                            * If an automatic snapshot has not yet been created for the current day, and you change the snapshot time to an earlier time of day, then the new snapshot time will be effective the following day and a snapshot is automatically created at the previously set time for the current day. This ensures that a snapshot is created for the current day.

                            * If an automatic snapshot has not yet been created for the current day, and you change the snapshot time to a time that is within 30 minutes from your current time, then the new snapshot time will be effective the following day and a snapshot is automatically created at the previously set time for the current day. This ensures that a snapshot is created for the current day, because 30 minutes is required between your current time and the new snapshot time that you specify.

                            * If an automatic snapshot is scheduled to be created within 30 minutes from your current time and you change the snapshot time, then the new snapshot time will be effective the following day and a snapshot is automatically created at the previously set time for the current day. This ensures that a snapshot is created for the current day, because 30 minutes is required between your current time and the new snapshot time that you specify.

                            type AutoSnapshotDetails

                            type AutoSnapshotDetails struct {
                            
                            	// The timestamp when the automatic snapshot was created.
                            	CreatedAt *time.Time
                            
                            	// The date of the automatic snapshot in YYYY-MM-DD format.
                            	Date *string
                            
                            	// An array of objects that describe the block storage disks attached to the
                            	// instance when the automatic snapshot was created.
                            	FromAttachedDisks []AttachedDisk
                            
                            	// The status of the automatic snapshot.
                            	Status AutoSnapshotStatus
                            }

                              Describes an automatic snapshot.

                              type AutoSnapshotStatus

                              type AutoSnapshotStatus string
                              const (
                              	AutoSnapshotStatusSuccess    AutoSnapshotStatus = "Success"
                              	AutoSnapshotStatusFailed     AutoSnapshotStatus = "Failed"
                              	AutoSnapshotStatusInProgress AutoSnapshotStatus = "InProgress"
                              	AutoSnapshotStatusNotFound   AutoSnapshotStatus = "NotFound"
                              )

                                Enum values for AutoSnapshotStatus

                                func (AutoSnapshotStatus) Values

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

                                  type AvailabilityZone

                                  type AvailabilityZone struct {
                                  
                                  	// The state of the Availability Zone.
                                  	State *string
                                  
                                  	// The name of the Availability Zone. The format is us-east-2a (case-sensitive).
                                  	ZoneName *string
                                  }

                                    Describes an Availability Zone.

                                    type BehaviorEnum

                                    type BehaviorEnum string
                                    const (
                                    	BehaviorEnumDontCacheSetting BehaviorEnum = "dont-cache"
                                    	BehaviorEnumCacheSetting     BehaviorEnum = "cache"
                                    )

                                      Enum values for BehaviorEnum

                                      func (BehaviorEnum) Values

                                      func (BehaviorEnum) Values() []BehaviorEnum

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

                                        type Blueprint

                                        type Blueprint struct {
                                        
                                        	// The ID for the virtual private server image (e.g., app_wordpress_4_4 or
                                        	// app_lamp_7_0).
                                        	BlueprintId *string
                                        
                                        	// The description of the blueprint.
                                        	Description *string
                                        
                                        	// The group name of the blueprint (e.g., amazon-linux).
                                        	Group *string
                                        
                                        	// A Boolean value indicating whether the blueprint is active. Inactive blueprints
                                        	// are listed to support customers with existing instances but are not necessarily
                                        	// available for launch of new instances. Blueprints are marked inactive when they
                                        	// become outdated due to operating system updates or new application releases.
                                        	IsActive *bool
                                        
                                        	// The end-user license agreement URL for the image or blueprint.
                                        	LicenseUrl *string
                                        
                                        	// The minimum bundle power required to run this blueprint. For example, you need a
                                        	// bundle with a power value of 500 or more to create an instance that uses a
                                        	// blueprint with a minimum power value of 500. 0 indicates that the blueprint runs
                                        	// on all instance sizes.
                                        	MinPower *int32
                                        
                                        	// The friendly name of the blueprint (e.g., Amazon Linux).
                                        	Name *string
                                        
                                        	// The operating system platform (either Linux/Unix-based or Windows Server-based)
                                        	// of the blueprint.
                                        	Platform InstancePlatform
                                        
                                        	// The product URL to learn more about the image or blueprint.
                                        	ProductUrl *string
                                        
                                        	// The type of the blueprint (e.g., os or app).
                                        	Type BlueprintType
                                        
                                        	// The version number of the operating system, application, or stack (e.g.,
                                        	// 2016.03.0).
                                        	Version *string
                                        
                                        	// The version code.
                                        	VersionCode *string
                                        }

                                          Describes a blueprint (a virtual private server image).

                                          type BlueprintType

                                          type BlueprintType string
                                          const (
                                          	BlueprintTypeOs  BlueprintType = "os"
                                          	BlueprintTypeApp BlueprintType = "app"
                                          )

                                            Enum values for BlueprintType

                                            func (BlueprintType) Values

                                            func (BlueprintType) Values() []BlueprintType

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

                                              type Bundle

                                              type Bundle struct {
                                              
                                              	// The bundle ID (e.g., micro_1_0).
                                              	BundleId *string
                                              
                                              	// The number of vCPUs included in the bundle (e.g., 2).
                                              	CpuCount *int32
                                              
                                              	// The size of the SSD (e.g., 30).
                                              	DiskSizeInGb *int32
                                              
                                              	// The Amazon EC2 instance type (e.g., t2.micro).
                                              	InstanceType *string
                                              
                                              	// A Boolean value indicating whether the bundle is active.
                                              	IsActive *bool
                                              
                                              	// A friendly name for the bundle (e.g., Micro).
                                              	Name *string
                                              
                                              	// A numeric value that represents the power of the bundle (e.g., 500). You can use
                                              	// the bundle's power value in conjunction with a blueprint's minimum power value
                                              	// to determine whether the blueprint will run on the bundle. For example, you need
                                              	// a bundle with a power value of 500 or more to create an instance that uses a
                                              	// blueprint with a minimum power value of 500.
                                              	Power *int32
                                              
                                              	// The price in US dollars (e.g., 5.0) of the bundle.
                                              	Price *float32
                                              
                                              	// The amount of RAM in GB (e.g., 2.0).
                                              	RamSizeInGb *float32
                                              
                                              	// The operating system platform (Linux/Unix-based or Windows Server-based) that
                                              	// the bundle supports. You can only launch a WINDOWS bundle on a blueprint that
                                              	// supports the WINDOWS platform. LINUX_UNIX blueprints require a LINUX_UNIX
                                              	// bundle.
                                              	SupportedPlatforms []InstancePlatform
                                              
                                              	// The data transfer rate per month in GB (e.g., 2000).
                                              	TransferPerMonthInGb *int32
                                              }

                                                Describes a bundle, which is a set of specs describing your virtual private server (or instance).

                                                type CacheBehavior

                                                type CacheBehavior struct {
                                                
                                                	// The cache behavior of the distribution. The following cache behaviors can be
                                                	// specified:
                                                	//
                                                	// * cache - This option is best for static sites. When specified, your
                                                	// distribution caches and serves your entire website as static content. This
                                                	// behavior is ideal for websites with static content that doesn't change depending
                                                	// on who views it, or for websites that don't use cookies, headers, or query
                                                	// strings to personalize content.
                                                	//
                                                	// * dont-cache - This option is best for sites
                                                	// that serve a mix of static and dynamic content. When specified, your
                                                	// distribution caches and serve only the content that is specified in the
                                                	// distribution's CacheBehaviorPerPath parameter. This behavior is ideal for
                                                	// websites or web applications that use cookies, headers, and query strings to
                                                	// personalize content for individual users.
                                                	Behavior BehaviorEnum
                                                }

                                                  Describes the default cache behavior of an Amazon Lightsail content delivery network (CDN) distribution.

                                                  type CacheBehaviorPerPath

                                                  type CacheBehaviorPerPath struct {
                                                  
                                                  	// The cache behavior for the specified path. You can specify one of the following
                                                  	// per-path cache behaviors:
                                                  	//
                                                  	// * cache - This behavior caches the specified path.
                                                  	//
                                                  	// *
                                                  	// dont-cache - This behavior doesn't cache the specified path.
                                                  	Behavior BehaviorEnum
                                                  
                                                  	// The path to a directory or file to cached, or not cache. Use an asterisk symbol
                                                  	// to specify wildcard directories (path/to/assets/*), and file types (*.html,
                                                  	// *jpg, *js). Directories and file paths are case-sensitive. Examples:
                                                  	//
                                                  	// * Specify
                                                  	// the following to cache all files in the document root of an Apache web server
                                                  	// running on a Lightsail instance. var/www/html/
                                                  	//
                                                  	// * Specify the following file to
                                                  	// cache only the index page in the document root of an Apache web server.
                                                  	// var/www/html/index.html
                                                  	//
                                                  	// * Specify the following to cache only the .html files
                                                  	// in the document root of an Apache web server. var/www/html/*.html
                                                  	//
                                                  	// * Specify the
                                                  	// following to cache only the .jpg, .png, and .gif files in the images
                                                  	// sub-directory of the document root of an Apache web server.
                                                  	// var/www/html/images/*.jpgvar/www/html/images/*.pngvar/www/html/images/*.gif
                                                  	// Specify the following to cache all files in the images sub-directory of the
                                                  	// document root of an Apache web server. var/www/html/images/
                                                  	Path *string
                                                  }

                                                    Describes the per-path cache behavior of an Amazon Lightsail content delivery network (CDN) distribution. A per-path cache behavior is used to override, or add an exception to, the default cache behavior of a distribution. For example, if the cacheBehavior is set to cache, then a per-path cache behavior can be used to specify a directory, file, or file type that your distribution will cache. Alternately, if the distribution's cacheBehavior is dont-cache, then a per-path cache behavior can be used to specify a directory, file, or file type that your distribution will not cache. if the cacheBehavior's behavior is set to 'cache', then

                                                    type CacheSettings

                                                    type CacheSettings struct {
                                                    
                                                    	// The HTTP methods that are processed and forwarded to the distribution's origin.
                                                    	// You can specify the following options:
                                                    	//
                                                    	// * GET,HEAD - The distribution forwards
                                                    	// the GET and HEAD methods.
                                                    	//
                                                    	// * GET,HEAD,OPTIONS - The distribution forwards the
                                                    	// GET, HEAD, and OPTIONS methods.
                                                    	//
                                                    	// * GET,HEAD,OPTIONS,PUT,PATCH,POST,DELETE - The
                                                    	// distribution forwards the GET, HEAD, OPTIONS, PUT, PATCH, POST, and DELETE
                                                    	// methods.
                                                    	//
                                                    	// If you specify the third option, you might need to restrict access to
                                                    	// your distribution's origin so users can't perform operations that you don't want
                                                    	// them to. For example, you might not want users to have permission to delete
                                                    	// objects from your origin.
                                                    	AllowedHTTPMethods *string
                                                    
                                                    	// The HTTP method responses that are cached by your distribution. You can specify
                                                    	// the following options:
                                                    	//
                                                    	// * GET,HEAD - The distribution caches responses to the
                                                    	// GET and HEAD methods.
                                                    	//
                                                    	// * GET,HEAD,OPTIONS - The distribution caches responses to
                                                    	// the GET, HEAD, and OPTIONS methods.
                                                    	CachedHTTPMethods *string
                                                    
                                                    	// The default amount of time that objects stay in the distribution's cache before
                                                    	// the distribution forwards another request to the origin to determine whether the
                                                    	// content has been updated. The value specified applies only when the origin does
                                                    	// not add HTTP headers such as Cache-Control max-age, Cache-Control s-maxage, and
                                                    	// Expires to objects.
                                                    	DefaultTTL *int64
                                                    
                                                    	// An object that describes the cookies that are forwarded to the origin. Your
                                                    	// content is cached based on the cookies that are forwarded.
                                                    	ForwardedCookies *CookieObject
                                                    
                                                    	// An object that describes the headers that are forwarded to the origin. Your
                                                    	// content is cached based on the headers that are forwarded.
                                                    	ForwardedHeaders *HeaderObject
                                                    
                                                    	// An object that describes the query strings that are forwarded to the origin.
                                                    	// Your content is cached based on the query strings that are forwarded.
                                                    	ForwardedQueryStrings *QueryStringObject
                                                    
                                                    	// The maximum amount of time that objects stay in the distribution's cache before
                                                    	// the distribution forwards another request to the origin to determine whether the
                                                    	// object has been updated. The value specified applies only when the origin adds
                                                    	// HTTP headers such as Cache-Control max-age, Cache-Control s-maxage, and Expires
                                                    	// to objects.
                                                    	MaximumTTL *int64
                                                    
                                                    	// The minimum amount of time that objects stay in the distribution's cache before
                                                    	// the distribution forwards another request to the origin to determine whether the
                                                    	// object has been updated. A value of 0 must be specified for minimumTTL if the
                                                    	// distribution is configured to forward all headers to the origin.
                                                    	MinimumTTL *int64
                                                    }

                                                      Describes the cache settings of an Amazon Lightsail content delivery network (CDN) distribution. These settings apply only to your distribution's cacheBehaviors (including the defaultCacheBehavior) that have a behavior of cache.

                                                      type Certificate

                                                      type Certificate struct {
                                                      
                                                      	// The Amazon Resource Name (ARN) of the certificate.
                                                      	Arn *string
                                                      
                                                      	// The timestamp when the certificate was created.
                                                      	CreatedAt *time.Time
                                                      
                                                      	// The domain name of the certificate.
                                                      	DomainName *string
                                                      
                                                      	// An array of objects that describe the domain validation records of the
                                                      	// certificate.
                                                      	DomainValidationRecords []DomainValidationRecord
                                                      
                                                      	// The renewal eligibility of the certificate.
                                                      	EligibleToRenew *string
                                                      
                                                      	// The number of Lightsail resources that the certificate is attached to.
                                                      	InUseResourceCount int32
                                                      
                                                      	// The timestamp when the certificate was issued.
                                                      	IssuedAt *time.Time
                                                      
                                                      	// The certificate authority that issued the certificate.
                                                      	IssuerCA *string
                                                      
                                                      	// The algorithm used to generate the key pair (the public and private key) of the
                                                      	// certificate.
                                                      	KeyAlgorithm *string
                                                      
                                                      	// The name of the certificate (e.g., my-certificate).
                                                      	Name *string
                                                      
                                                      	// The timestamp when the certificate expires.
                                                      	NotAfter *time.Time
                                                      
                                                      	// The timestamp when the certificate is first valid.
                                                      	NotBefore *time.Time
                                                      
                                                      	// An object that describes the status of the certificate renewal managed by
                                                      	// Lightsail.
                                                      	RenewalSummary *RenewalSummary
                                                      
                                                      	// The validation failure reason, if any, of the certificate. The following failure
                                                      	// reasons are possible:
                                                      	//
                                                      	// * NO_AVAILABLE_CONTACTS - This failure applies to email
                                                      	// validation, which is not available for Lightsail certificates.
                                                      	//
                                                      	// *
                                                      	// ADDITIONAL_VERIFICATION_REQUIRED - Lightsail requires additional information to
                                                      	// process this certificate request. This can happen as a fraud-protection measure,
                                                      	// such as when the domain ranks within the Alexa top 1000 websites. To provide the
                                                      	// required information, use the AWS Support Center
                                                      	// (https://console.aws.amazon.com/support/home) to contact AWS Support. You cannot
                                                      	// request a certificate for Amazon-owned domain names such as those ending in
                                                      	// amazonaws.com, cloudfront.net, or elasticbeanstalk.com.
                                                      	//
                                                      	// * DOMAIN_NOT_ALLOWED -
                                                      	// One or more of the domain names in the certificate request was reported as an
                                                      	// unsafe domain by VirusTotal (https://www.virustotal.com/gui/home/url). To
                                                      	// correct the problem, search for your domain name on the VirusTotal
                                                      	// (https://www.virustotal.com/gui/home/url) website. If your domain is reported as
                                                      	// suspicious, see Google Help for Hacked Websites
                                                      	// (https://www.google.com/webmasters/hacked/?hl=en) to learn what you can do. If
                                                      	// you believe that the result is a false positive, notify the organization that is
                                                      	// reporting the domain. VirusTotal is an aggregate of several antivirus and URL
                                                      	// scanners and cannot remove your domain from a block list itself. After you
                                                      	// correct the problem and the VirusTotal registry has been updated, request a new
                                                      	// certificate. If you see this error and your domain is not included in the
                                                      	// VirusTotal list, visit the AWS Support Center
                                                      	// (https://console.aws.amazon.com/support/home) and create a case.
                                                      	//
                                                      	// *
                                                      	// INVALID_PUBLIC_DOMAIN - One or more of the domain names in the certificate
                                                      	// request is not valid. Typically, this is because a domain name in the request is
                                                      	// not a valid top-level domain. Try to request a certificate again, correcting any
                                                      	// spelling errors or typos that were in the failed request, and ensure that all
                                                      	// domain names in the request are for valid top-level domains. For example, you
                                                      	// cannot request a certificate for example.invalidpublicdomain because
                                                      	// invalidpublicdomain is not a valid top-level domain.
                                                      	//
                                                      	// * OTHER - Typically, this
                                                      	// failure occurs when there is a typographical error in one or more of the domain
                                                      	// names in the certificate request. Try to request a certificate again, correcting
                                                      	// any spelling errors or typos that were in the failed request.
                                                      	RequestFailureReason *string
                                                      
                                                      	// The reason the certificate was revoked. This value is present only when the
                                                      	// certificate status is REVOKED.
                                                      	RevocationReason *string
                                                      
                                                      	// The timestamp when the certificate was revoked. This value is present only when
                                                      	// the certificate status is REVOKED.
                                                      	RevokedAt *time.Time
                                                      
                                                      	// The serial number of the certificate.
                                                      	SerialNumber *string
                                                      
                                                      	// The validation status of the certificate.
                                                      	Status CertificateStatus
                                                      
                                                      	// An array of strings that specify the alternate domains (e.g., example2.com) and
                                                      	// subdomains (e.g., blog.example.com) of the certificate.
                                                      	SubjectAlternativeNames []string
                                                      
                                                      	// The support code. Include this code in your email to support when you have
                                                      	// questions about your Lightsail certificate. This code enables our support team
                                                      	// to look up your Lightsail information more easily.
                                                      	SupportCode *string
                                                      
                                                      	// The tag keys and optional values for the resource. For more information about
                                                      	// tags in Lightsail, see the Lightsail Dev Guide
                                                      	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                      	Tags []Tag
                                                      }

                                                        Describes the full details of an Amazon Lightsail SSL/TLS certificate. To get a summary of a certificate, use the GetCertificates action and ommit includeCertificateDetails from your request. The response will include only the certificate Amazon Resource Name (ARN), certificate name, domain name, and tags.

                                                        type CertificateStatus

                                                        type CertificateStatus string
                                                        const (
                                                        	CertificateStatusPendingValidation  CertificateStatus = "PENDING_VALIDATION"
                                                        	CertificateStatusIssued             CertificateStatus = "ISSUED"
                                                        	CertificateStatusInactive           CertificateStatus = "INACTIVE"
                                                        	CertificateStatusExpired            CertificateStatus = "EXPIRED"
                                                        	CertificateStatusValidationTimedOut CertificateStatus = "VALIDATION_TIMED_OUT"
                                                        	CertificateStatusRevoked            CertificateStatus = "REVOKED"
                                                        	CertificateStatusFailed             CertificateStatus = "FAILED"
                                                        )

                                                          Enum values for CertificateStatus

                                                          func (CertificateStatus) Values

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

                                                            type CertificateSummary

                                                            type CertificateSummary struct {
                                                            
                                                            	// The Amazon Resource Name (ARN) of the certificate.
                                                            	CertificateArn *string
                                                            
                                                            	// An object that describes a certificate in detail.
                                                            	CertificateDetail *Certificate
                                                            
                                                            	// The name of the certificate.
                                                            	CertificateName *string
                                                            
                                                            	// The domain name of the certificate.
                                                            	DomainName *string
                                                            
                                                            	// The tag keys and optional values for the resource. For more information about
                                                            	// tags in Lightsail, see the Lightsail Dev Guide
                                                            	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                            	Tags []Tag
                                                            }

                                                              Describes an Amazon Lightsail SSL/TLS certificate.

                                                              type CloudFormationStackRecord

                                                              type CloudFormationStackRecord struct {
                                                              
                                                              	// The Amazon Resource Name (ARN) of the CloudFormation stack record.
                                                              	Arn *string
                                                              
                                                              	// The date when the CloudFormation stack record was created.
                                                              	CreatedAt *time.Time
                                                              
                                                              	// A list of objects describing the destination service, which is AWS
                                                              	// CloudFormation, and the Amazon Resource Name (ARN) of the AWS CloudFormation
                                                              	// stack.
                                                              	DestinationInfo *DestinationInfo
                                                              
                                                              	// A list of objects describing the Availability Zone and AWS Region of the
                                                              	// CloudFormation stack record.
                                                              	Location *ResourceLocation
                                                              
                                                              	// The name of the CloudFormation stack record. It starts with
                                                              	// CloudFormationStackRecord followed by a GUID.
                                                              	Name *string
                                                              
                                                              	// The Lightsail resource type (e.g., CloudFormationStackRecord).
                                                              	ResourceType ResourceType
                                                              
                                                              	// A list of objects describing the source of the CloudFormation stack record.
                                                              	SourceInfo []CloudFormationStackRecordSourceInfo
                                                              
                                                              	// The current state of the CloudFormation stack record.
                                                              	State RecordState
                                                              }

                                                                Describes a CloudFormation stack record created as a result of the create cloud formation stack operation. A CloudFormation stack record provides information about the AWS CloudFormation stack used to create a new Amazon Elastic Compute Cloud instance from an exported Lightsail instance snapshot.

                                                                type CloudFormationStackRecordSourceInfo

                                                                type CloudFormationStackRecordSourceInfo struct {
                                                                
                                                                	// The Amazon Resource Name (ARN) of the export snapshot record.
                                                                	Arn *string
                                                                
                                                                	// The name of the record.
                                                                	Name *string
                                                                
                                                                	// The Lightsail resource type (e.g., ExportSnapshotRecord).
                                                                	ResourceType CloudFormationStackRecordSourceType
                                                                }

                                                                  Describes the source of a CloudFormation stack record (i.e., the export snapshot record).

                                                                  type CloudFormationStackRecordSourceType

                                                                  type CloudFormationStackRecordSourceType string
                                                                  const (
                                                                  	CloudFormationStackRecordSourceTypeExportSnapshotRecord CloudFormationStackRecordSourceType = "ExportSnapshotRecord"
                                                                  )

                                                                    Enum values for CloudFormationStackRecordSourceType

                                                                    func (CloudFormationStackRecordSourceType) Values

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

                                                                      type ComparisonOperator

                                                                      type ComparisonOperator string
                                                                      const (
                                                                      	ComparisonOperatorGreaterThanOrEqualToThreshold ComparisonOperator = "GreaterThanOrEqualToThreshold"
                                                                      	ComparisonOperatorGreaterThanThreshold          ComparisonOperator = "GreaterThanThreshold"
                                                                      	ComparisonOperatorLessThanThreshold             ComparisonOperator = "LessThanThreshold"
                                                                      	ComparisonOperatorLessThanOrEqualToThreshold    ComparisonOperator = "LessThanOrEqualToThreshold"
                                                                      )

                                                                        Enum values for ComparisonOperator

                                                                        func (ComparisonOperator) Values

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

                                                                          type ContactMethod

                                                                          type ContactMethod struct {
                                                                          
                                                                          	// The Amazon Resource Name (ARN) of the contact method.
                                                                          	Arn *string
                                                                          
                                                                          	// The destination of the contact method, such as an email address or a mobile
                                                                          	// phone number.
                                                                          	ContactEndpoint *string
                                                                          
                                                                          	// The timestamp when the contact method was created.
                                                                          	CreatedAt *time.Time
                                                                          
                                                                          	// Describes the resource location.
                                                                          	Location *ResourceLocation
                                                                          
                                                                          	// The name of the contact method.
                                                                          	Name *string
                                                                          
                                                                          	// The protocol of the contact method, such as email or SMS (text messaging).
                                                                          	Protocol ContactProtocol
                                                                          
                                                                          	// The Lightsail resource type (e.g., ContactMethod).
                                                                          	ResourceType ResourceType
                                                                          
                                                                          	// The current status of the contact method. A contact method has the following
                                                                          	// possible status:
                                                                          	//
                                                                          	// * PendingVerification - The contact method has not yet been
                                                                          	// verified, and the verification has not yet expired.
                                                                          	//
                                                                          	// * Valid - The contact
                                                                          	// method has been verified.
                                                                          	//
                                                                          	// * InValid - An attempt was made to verify the contact
                                                                          	// method, but the verification has expired.
                                                                          	Status ContactMethodStatus
                                                                          
                                                                          	// The support code. Include this code in your email to support when you have
                                                                          	// questions about your Lightsail contact method. This code enables our support
                                                                          	// team to look up your Lightsail information more easily.
                                                                          	SupportCode *string
                                                                          }

                                                                            Describes a contact method. A contact method is a way to send you notifications. For more information, see Notifications in Amazon Lightsail (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-notifications).

                                                                            type ContactMethodStatus

                                                                            type ContactMethodStatus string
                                                                            const (
                                                                            	ContactMethodStatusPendingVerification ContactMethodStatus = "PendingVerification"
                                                                            	ContactMethodStatusValid               ContactMethodStatus = "Valid"
                                                                            	ContactMethodStatusInvalid             ContactMethodStatus = "Invalid"
                                                                            )

                                                                              Enum values for ContactMethodStatus

                                                                              func (ContactMethodStatus) Values

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

                                                                                type ContactMethodVerificationProtocol

                                                                                type ContactMethodVerificationProtocol string
                                                                                const (
                                                                                	ContactMethodVerificationProtocolEmail ContactMethodVerificationProtocol = "Email"
                                                                                )

                                                                                  Enum values for ContactMethodVerificationProtocol

                                                                                  func (ContactMethodVerificationProtocol) Values

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

                                                                                    type ContactProtocol

                                                                                    type ContactProtocol string
                                                                                    const (
                                                                                    	ContactProtocolEmail ContactProtocol = "Email"
                                                                                    	ContactProtocolSms   ContactProtocol = "SMS"
                                                                                    )

                                                                                      Enum values for ContactProtocol

                                                                                      func (ContactProtocol) Values

                                                                                      func (ContactProtocol) Values() []ContactProtocol

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

                                                                                        type Container

                                                                                        type Container struct {
                                                                                        
                                                                                        	// The launch command for the container.
                                                                                        	Command []string
                                                                                        
                                                                                        	// The environment variables of the container.
                                                                                        	Environment map[string]string
                                                                                        
                                                                                        	// The name of the image used for the container. Container images sourced from your
                                                                                        	// Lightsail container service, that are registered and stored on your service,
                                                                                        	// start with a colon (:). For example, :container-service-1.mystaticwebsite.1.
                                                                                        	// Container images sourced from a public registry like Docker Hub don't start with
                                                                                        	// a colon. For example, nginx:latest or nginx.
                                                                                        	Image *string
                                                                                        
                                                                                        	// The open firewall ports of the container.
                                                                                        	Ports map[string]ContainerServiceProtocol
                                                                                        }

                                                                                          Describes the settings of a container that will be launched, or that is launched, to an Amazon Lightsail container service.

                                                                                          type ContainerImage

                                                                                          type ContainerImage struct {
                                                                                          
                                                                                          	// The timestamp when the container image was created.
                                                                                          	CreatedAt *time.Time
                                                                                          
                                                                                          	// The digest of the container image.
                                                                                          	Digest *string
                                                                                          
                                                                                          	// The name of the container image.
                                                                                          	Image *string
                                                                                          }

                                                                                            Describes a container image that is registered to an Amazon Lightsail container service.

                                                                                            type ContainerService

                                                                                            type ContainerService struct {
                                                                                            
                                                                                            	// The Amazon Resource Name (ARN) of the container service.
                                                                                            	Arn *string
                                                                                            
                                                                                            	// The name of the container service.
                                                                                            	ContainerServiceName *string
                                                                                            
                                                                                            	// The timestamp when the container service was created.
                                                                                            	CreatedAt *time.Time
                                                                                            
                                                                                            	// An object that describes the current container deployment of the container
                                                                                            	// service.
                                                                                            	CurrentDeployment *ContainerServiceDeployment
                                                                                            
                                                                                            	// A Boolean value indicating whether the container service is disabled.
                                                                                            	IsDisabled *bool
                                                                                            
                                                                                            	// An object that describes the location of the container service, such as the AWS
                                                                                            	// Region and Availability Zone.
                                                                                            	Location *ResourceLocation
                                                                                            
                                                                                            	// An object that describes the next deployment of the container service. This
                                                                                            	// value is null when there is no deployment in a pending state.
                                                                                            	NextDeployment *ContainerServiceDeployment
                                                                                            
                                                                                            	// The power specification of the container service. The power specifies the amount
                                                                                            	// of RAM, the number of vCPUs, and the base price of the container service.
                                                                                            	Power ContainerServicePowerName
                                                                                            
                                                                                            	// The ID of the power of the container service.
                                                                                            	PowerId *string
                                                                                            
                                                                                            	// The principal ARN of the container service. The principal ARN can be used to
                                                                                            	// create a trust relationship between your standard AWS account and your Lightsail
                                                                                            	// container service. This allows you to give your service permission to access
                                                                                            	// resources in your standard AWS account.
                                                                                            	PrincipalArn *string
                                                                                            
                                                                                            	// The private domain name of the container service. The private domain name is
                                                                                            	// accessible only by other resources within the default virtual private cloud
                                                                                            	// (VPC) of your Lightsail account.
                                                                                            	PrivateDomainName *string
                                                                                            
                                                                                            	// The public domain name of the container service, such as example.com and
                                                                                            	// www.example.com. You can specify up to four public domain names for a container
                                                                                            	// service. The domain names that you specify are used when you create a deployment
                                                                                            	// with a container configured as the public endpoint of your container service. If
                                                                                            	// you don't specify public domain names, then you can use the default domain of
                                                                                            	// the container service. You must create and validate an SSL/TLS certificate
                                                                                            	// before you can use public domain names with your container service. Use the
                                                                                            	// CreateCertificate action to create a certificate for the public domain names you
                                                                                            	// want to use with your container service. See CreateContainerService or
                                                                                            	// UpdateContainerService for information about how to specify public domain names
                                                                                            	// for your Lightsail container service.
                                                                                            	PublicDomainNames map[string][]string
                                                                                            
                                                                                            	// The Lightsail resource type of the container service (i.e., ContainerService).
                                                                                            	ResourceType ResourceType
                                                                                            
                                                                                            	// The scale specification of the container service. The scale specifies the
                                                                                            	// allocated compute nodes of the container service.
                                                                                            	Scale *int32
                                                                                            
                                                                                            	// The current state of the container service. The state can be:
                                                                                            	//
                                                                                            	// * Pending - The
                                                                                            	// container service is being created.
                                                                                            	//
                                                                                            	// * Ready - The container service is created
                                                                                            	// but does not have a container deployment.
                                                                                            	//
                                                                                            	// * Disabled - The container service is
                                                                                            	// disabled.
                                                                                            	//
                                                                                            	// * Updating - The container service capacity or other setting is being
                                                                                            	// updated.
                                                                                            	//
                                                                                            	// * Deploying - The container service is launching a container
                                                                                            	// deployment.
                                                                                            	//
                                                                                            	// * Running - The container service is created and it has a container
                                                                                            	// deployment.
                                                                                            	State ContainerServiceState
                                                                                            
                                                                                            	// The tag keys and optional values for the resource. For more information about
                                                                                            	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                            	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                            	Tags []Tag
                                                                                            
                                                                                            	// The publicly accessible URL of the container service. If no public endpoint is
                                                                                            	// specified in the currentDeployment, this URL returns a 404 response.
                                                                                            	Url *string
                                                                                            }

                                                                                              Describes an Amazon Lightsail container service.

                                                                                              type ContainerServiceDeployment

                                                                                              type ContainerServiceDeployment struct {
                                                                                              
                                                                                              	// An object that describes the configuration for the containers of the deployment.
                                                                                              	Containers map[string]Container
                                                                                              
                                                                                              	// The timestamp when the deployment was created.
                                                                                              	CreatedAt *time.Time
                                                                                              
                                                                                              	// An object that describes the endpoint of the deployment.
                                                                                              	PublicEndpoint *ContainerServiceEndpoint
                                                                                              
                                                                                              	// The state of the deployment. A deployment can be in one of the following
                                                                                              	// states:
                                                                                              	//
                                                                                              	// * Activating - The deployment is being created.
                                                                                              	//
                                                                                              	// * Active - The
                                                                                              	// deployment was successfully created, and it's currently running on the container
                                                                                              	// service. The container service can have only one deployment in an active state
                                                                                              	// at a time.
                                                                                              	//
                                                                                              	// * Inactive - The deployment was previously successfully created, but
                                                                                              	// it is not currently running on the container service.
                                                                                              	//
                                                                                              	// * Failed - The deployment
                                                                                              	// failed. Use the GetContainerLog action to view the log events for the containers
                                                                                              	// in the deployment to try to determine the reason for the failure.
                                                                                              	State ContainerServiceDeploymentState
                                                                                              
                                                                                              	// The version number of the deployment.
                                                                                              	Version *int32
                                                                                              }

                                                                                                Describes a container deployment configuration of an Amazon Lightsail container service. A deployment specifies the settings, such as the ports and launch command, of containers that are deployed to your container service.

                                                                                                type ContainerServiceDeploymentRequest

                                                                                                type ContainerServiceDeploymentRequest struct {
                                                                                                
                                                                                                	// An object that describes the configuration for the containers of the deployment.
                                                                                                	Containers map[string]Container
                                                                                                
                                                                                                	// An object that describes the endpoint of the deployment.
                                                                                                	PublicEndpoint *EndpointRequest
                                                                                                }

                                                                                                  Describes a container deployment configuration of an Amazon Lightsail container service. A deployment specifies the settings, such as the ports and launch command, of containers that are deployed to your container service.

                                                                                                  type ContainerServiceDeploymentState

                                                                                                  type ContainerServiceDeploymentState string
                                                                                                  const (
                                                                                                  	ContainerServiceDeploymentStateActivating ContainerServiceDeploymentState = "ACTIVATING"
                                                                                                  	ContainerServiceDeploymentStateActive     ContainerServiceDeploymentState = "ACTIVE"
                                                                                                  	ContainerServiceDeploymentStateInactive   ContainerServiceDeploymentState = "INACTIVE"
                                                                                                  	ContainerServiceDeploymentStateFailed     ContainerServiceDeploymentState = "FAILED"
                                                                                                  )

                                                                                                    Enum values for ContainerServiceDeploymentState

                                                                                                    func (ContainerServiceDeploymentState) Values

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

                                                                                                      type ContainerServiceEndpoint

                                                                                                      type ContainerServiceEndpoint struct {
                                                                                                      
                                                                                                      	// The name of the container entry of the deployment that the endpoint
                                                                                                      	// configuration applies to.
                                                                                                      	ContainerName *string
                                                                                                      
                                                                                                      	// The port of the specified container to which traffic is forwarded to.
                                                                                                      	ContainerPort *int32
                                                                                                      
                                                                                                      	// An object that describes the health check configuration of the container.
                                                                                                      	HealthCheck *ContainerServiceHealthCheckConfig
                                                                                                      }

                                                                                                        Describes the public endpoint configuration of a deployment of an Amazon Lightsail container service.

                                                                                                        type ContainerServiceHealthCheckConfig

                                                                                                        type ContainerServiceHealthCheckConfig struct {
                                                                                                        
                                                                                                        	// The number of consecutive health checks successes required before moving the
                                                                                                        	// container to the Healthy state.
                                                                                                        	HealthyThreshold *int32
                                                                                                        
                                                                                                        	// The approximate interval, in seconds, between health checks of an individual
                                                                                                        	// container. You may specify between 5 and 300 seconds.
                                                                                                        	IntervalSeconds *int32
                                                                                                        
                                                                                                        	// The path on the container on which to perform the health check.
                                                                                                        	Path *string
                                                                                                        
                                                                                                        	// The HTTP codes to use when checking for a successful response from a container.
                                                                                                        	// You can specify values between 200 and 499.
                                                                                                        	SuccessCodes *string
                                                                                                        
                                                                                                        	// The amount of time, in seconds, during which no response means a failed health
                                                                                                        	// check. You may specify between 2 and 60 seconds.
                                                                                                        	TimeoutSeconds *int32
                                                                                                        
                                                                                                        	// The number of consecutive health check failures required before moving the
                                                                                                        	// container to the Unhealthy state.
                                                                                                        	UnhealthyThreshold *int32
                                                                                                        }

                                                                                                          Describes the health check configuration of an Amazon Lightsail container service.

                                                                                                          type ContainerServiceLogEvent

                                                                                                          type ContainerServiceLogEvent struct {
                                                                                                          
                                                                                                          	// The timestamp when the container service log event was created.
                                                                                                          	CreatedAt *time.Time
                                                                                                          
                                                                                                          	// The message of the container service log event.
                                                                                                          	Message *string
                                                                                                          }

                                                                                                            Describes the log events of a container of an Amazon Lightsail container service.

                                                                                                            type ContainerServiceMetricName

                                                                                                            type ContainerServiceMetricName string
                                                                                                            const (
                                                                                                            	ContainerServiceMetricNameCPUUtilization    ContainerServiceMetricName = "CPUUtilization"
                                                                                                            	ContainerServiceMetricNameMemoryUtilization ContainerServiceMetricName = "MemoryUtilization"
                                                                                                            )

                                                                                                              Enum values for ContainerServiceMetricName

                                                                                                              func (ContainerServiceMetricName) Values

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

                                                                                                                type ContainerServicePower

                                                                                                                type ContainerServicePower struct {
                                                                                                                
                                                                                                                	// The number of vCPUs included in the power.
                                                                                                                	CpuCount *float32
                                                                                                                
                                                                                                                	// A Boolean value indicating whether the power is active and can be specified for
                                                                                                                	// container services.
                                                                                                                	IsActive *bool
                                                                                                                
                                                                                                                	// The friendly name of the power (e.g., nano).
                                                                                                                	Name *string
                                                                                                                
                                                                                                                	// The ID of the power (e.g., nano-1).
                                                                                                                	PowerId *string
                                                                                                                
                                                                                                                	// The monthly price of the power in USD.
                                                                                                                	Price *float32
                                                                                                                
                                                                                                                	// The amount of RAM (in GB) of the power.
                                                                                                                	RamSizeInGb *float32
                                                                                                                }

                                                                                                                  Describes the powers that can be specified for an Amazon Lightsail container service. The power specifies the amount of RAM, the number of vCPUs, and the base price of the container service.

                                                                                                                  type ContainerServicePowerName

                                                                                                                  type ContainerServicePowerName string
                                                                                                                  const (
                                                                                                                  	ContainerServicePowerNameNano   ContainerServicePowerName = "nano"
                                                                                                                  	ContainerServicePowerNameMicro  ContainerServicePowerName = "micro"
                                                                                                                  	ContainerServicePowerNameSmall  ContainerServicePowerName = "small"
                                                                                                                  	ContainerServicePowerNameMedium ContainerServicePowerName = "medium"
                                                                                                                  	ContainerServicePowerNameLarge  ContainerServicePowerName = "large"
                                                                                                                  	ContainerServicePowerNameXlarge ContainerServicePowerName = "xlarge"
                                                                                                                  )

                                                                                                                    Enum values for ContainerServicePowerName

                                                                                                                    func (ContainerServicePowerName) Values

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

                                                                                                                      type ContainerServiceProtocol

                                                                                                                      type ContainerServiceProtocol string
                                                                                                                      const (
                                                                                                                      	ContainerServiceProtocolHttp  ContainerServiceProtocol = "HTTP"
                                                                                                                      	ContainerServiceProtocolHttps ContainerServiceProtocol = "HTTPS"
                                                                                                                      	ContainerServiceProtocolTcp   ContainerServiceProtocol = "TCP"
                                                                                                                      	ContainerServiceProtocolUdp   ContainerServiceProtocol = "UDP"
                                                                                                                      )

                                                                                                                        Enum values for ContainerServiceProtocol

                                                                                                                        func (ContainerServiceProtocol) Values

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

                                                                                                                          type ContainerServiceRegistryLogin

                                                                                                                          type ContainerServiceRegistryLogin struct {
                                                                                                                          
                                                                                                                          	// The timestamp of when the container image registry username and password expire.
                                                                                                                          	// The log in credentials expire 12 hours after they are created, at which point
                                                                                                                          	// you will need to create a new set of log in credentials using the
                                                                                                                          	// CreateContainerServiceRegistryLogin action.
                                                                                                                          	ExpiresAt *time.Time
                                                                                                                          
                                                                                                                          	// The container service registry password to use to push container images to the
                                                                                                                          	// container image registry of a Lightsail account
                                                                                                                          	Password *string
                                                                                                                          
                                                                                                                          	// The address to use to push container images to the container image registry of a
                                                                                                                          	// Lightsail account.
                                                                                                                          	Registry *string
                                                                                                                          
                                                                                                                          	// The container service registry username to use to push container images to the
                                                                                                                          	// container image registry of a Lightsail account.
                                                                                                                          	Username *string
                                                                                                                          }

                                                                                                                            Describes the login information for the container image registry of an Amazon Lightsail account.

                                                                                                                            type ContainerServiceState

                                                                                                                            type ContainerServiceState string
                                                                                                                            const (
                                                                                                                            	ContainerServiceStatePending  ContainerServiceState = "PENDING"
                                                                                                                            	ContainerServiceStateReady    ContainerServiceState = "READY"
                                                                                                                            	ContainerServiceStateRunning  ContainerServiceState = "RUNNING"
                                                                                                                            	ContainerServiceStateUpdating ContainerServiceState = "UPDATING"
                                                                                                                            	ContainerServiceStateDeleting ContainerServiceState = "DELETING"
                                                                                                                            	ContainerServiceStateDisabled ContainerServiceState = "DISABLED"
                                                                                                                            )

                                                                                                                              Enum values for ContainerServiceState

                                                                                                                              func (ContainerServiceState) Values

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

                                                                                                                                type CookieObject

                                                                                                                                type CookieObject struct {
                                                                                                                                
                                                                                                                                	// The specific cookies to forward to your distribution's origin.
                                                                                                                                	CookiesAllowList []string
                                                                                                                                
                                                                                                                                	// Specifies which cookies to forward to the distribution's origin for a cache
                                                                                                                                	// behavior: all, none, or allow-list to forward only the cookies specified in the
                                                                                                                                	// cookiesAllowList parameter.
                                                                                                                                	Option ForwardValues
                                                                                                                                }

                                                                                                                                  Describes whether an Amazon Lightsail content delivery network (CDN) distribution forwards cookies to the origin and, if so, which ones. For the cookies that you specify, your distribution caches separate versions of the specified content based on the cookie values in viewer requests.

                                                                                                                                  type DestinationInfo

                                                                                                                                  type DestinationInfo struct {
                                                                                                                                  
                                                                                                                                  	// The ID of the resource created at the destination.
                                                                                                                                  	Id *string
                                                                                                                                  
                                                                                                                                  	// The destination service of the record.
                                                                                                                                  	Service *string
                                                                                                                                  }

                                                                                                                                    Describes the destination of a record.

                                                                                                                                    type Disk

                                                                                                                                    type Disk struct {
                                                                                                                                    
                                                                                                                                    	// An array of objects representing the add-ons enabled on the disk.
                                                                                                                                    	AddOns []AddOn
                                                                                                                                    
                                                                                                                                    	// The Amazon Resource Name (ARN) of the disk.
                                                                                                                                    	Arn *string
                                                                                                                                    
                                                                                                                                    	// The resources to which the disk is attached.
                                                                                                                                    	AttachedTo *string
                                                                                                                                    
                                                                                                                                    	// (Deprecated) The attachment state of the disk. In releases prior to November 14,
                                                                                                                                    	// 2017, this parameter returned attached for system disks in the API response. It
                                                                                                                                    	// is now deprecated, but still included in the response. Use isAttached instead.
                                                                                                                                    	//
                                                                                                                                    	// Deprecated: This member has been deprecated.
                                                                                                                                    	AttachmentState *string
                                                                                                                                    
                                                                                                                                    	// The date when the disk was created.
                                                                                                                                    	CreatedAt *time.Time
                                                                                                                                    
                                                                                                                                    	// (Deprecated) The number of GB in use by the disk. In releases prior to November
                                                                                                                                    	// 14, 2017, this parameter was not included in the API response. It is now
                                                                                                                                    	// deprecated.
                                                                                                                                    	//
                                                                                                                                    	// Deprecated: This member has been deprecated.
                                                                                                                                    	GbInUse *int32
                                                                                                                                    
                                                                                                                                    	// The input/output operations per second (IOPS) of the disk.
                                                                                                                                    	Iops *int32
                                                                                                                                    
                                                                                                                                    	// A Boolean value indicating whether the disk is attached.
                                                                                                                                    	IsAttached *bool
                                                                                                                                    
                                                                                                                                    	// A Boolean value indicating whether this disk is a system disk (has an operating
                                                                                                                                    	// system loaded on it).
                                                                                                                                    	IsSystemDisk *bool
                                                                                                                                    
                                                                                                                                    	// The AWS Region and Availability Zone where the disk is located.
                                                                                                                                    	Location *ResourceLocation
                                                                                                                                    
                                                                                                                                    	// The unique name of the disk.
                                                                                                                                    	Name *string
                                                                                                                                    
                                                                                                                                    	// The disk path.
                                                                                                                                    	Path *string
                                                                                                                                    
                                                                                                                                    	// The Lightsail resource type (e.g., Disk).
                                                                                                                                    	ResourceType ResourceType
                                                                                                                                    
                                                                                                                                    	// The size of the disk in GB.
                                                                                                                                    	SizeInGb *int32
                                                                                                                                    
                                                                                                                                    	// Describes the status of the disk.
                                                                                                                                    	State DiskState
                                                                                                                                    
                                                                                                                                    	// The support code. Include this code in your email to support when you have
                                                                                                                                    	// questions about an instance or another resource in Lightsail. This code enables
                                                                                                                                    	// our support team to look up your Lightsail information more easily.
                                                                                                                                    	SupportCode *string
                                                                                                                                    
                                                                                                                                    	// The tag keys and optional values for the resource. For more information about
                                                                                                                                    	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                                                                    	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                                                                    	Tags []Tag
                                                                                                                                    }

                                                                                                                                      Describes a system disk or a block storage disk.

                                                                                                                                      type DiskInfo

                                                                                                                                      type DiskInfo struct {
                                                                                                                                      
                                                                                                                                      	// A Boolean value indicating whether this disk is a system disk (has an operating
                                                                                                                                      	// system loaded on it).
                                                                                                                                      	IsSystemDisk *bool
                                                                                                                                      
                                                                                                                                      	// The disk name.
                                                                                                                                      	Name *string
                                                                                                                                      
                                                                                                                                      	// The disk path.
                                                                                                                                      	Path *string
                                                                                                                                      
                                                                                                                                      	// The size of the disk in GB (e.g., 32).
                                                                                                                                      	SizeInGb *int32
                                                                                                                                      }

                                                                                                                                        Describes a disk.

                                                                                                                                        type DiskMap

                                                                                                                                        type DiskMap struct {
                                                                                                                                        
                                                                                                                                        	// The new disk name (e.g., my-new-disk).
                                                                                                                                        	NewDiskName *string
                                                                                                                                        
                                                                                                                                        	// The original disk path exposed to the instance (for example, /dev/sdh).
                                                                                                                                        	OriginalDiskPath *string
                                                                                                                                        }

                                                                                                                                          Describes a block storage disk mapping.

                                                                                                                                          type DiskSnapshot

                                                                                                                                          type DiskSnapshot struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) of the disk snapshot.
                                                                                                                                          	Arn *string
                                                                                                                                          
                                                                                                                                          	// The date when the disk snapshot was created.
                                                                                                                                          	CreatedAt *time.Time
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) of the source disk from which the disk snapshot
                                                                                                                                          	// was created.
                                                                                                                                          	FromDiskArn *string
                                                                                                                                          
                                                                                                                                          	// The unique name of the source disk from which the disk snapshot was created.
                                                                                                                                          	FromDiskName *string
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) of the source instance from which the disk
                                                                                                                                          	// (system volume) snapshot was created.
                                                                                                                                          	FromInstanceArn *string
                                                                                                                                          
                                                                                                                                          	// The unique name of the source instance from which the disk (system volume)
                                                                                                                                          	// snapshot was created.
                                                                                                                                          	FromInstanceName *string
                                                                                                                                          
                                                                                                                                          	// A Boolean value indicating whether the snapshot was created from an automatic
                                                                                                                                          	// snapshot.
                                                                                                                                          	IsFromAutoSnapshot *bool
                                                                                                                                          
                                                                                                                                          	// The AWS Region and Availability Zone where the disk snapshot was created.
                                                                                                                                          	Location *ResourceLocation
                                                                                                                                          
                                                                                                                                          	// The name of the disk snapshot (e.g., my-disk-snapshot).
                                                                                                                                          	Name *string
                                                                                                                                          
                                                                                                                                          	// The progress of the disk snapshot operation.
                                                                                                                                          	Progress *string
                                                                                                                                          
                                                                                                                                          	// The Lightsail resource type (e.g., DiskSnapshot).
                                                                                                                                          	ResourceType ResourceType
                                                                                                                                          
                                                                                                                                          	// The size of the disk in GB.
                                                                                                                                          	SizeInGb *int32
                                                                                                                                          
                                                                                                                                          	// The status of the disk snapshot operation.
                                                                                                                                          	State DiskSnapshotState
                                                                                                                                          
                                                                                                                                          	// The support code. Include this code in your email to support when you have
                                                                                                                                          	// questions about an instance or another resource in Lightsail. This code enables
                                                                                                                                          	// our support team to look up your Lightsail information more easily.
                                                                                                                                          	SupportCode *string
                                                                                                                                          
                                                                                                                                          	// The tag keys and optional values for the resource. For more information about
                                                                                                                                          	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                                                                          	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                                                                          	Tags []Tag
                                                                                                                                          }

                                                                                                                                            Describes a block storage disk snapshot.

                                                                                                                                            type DiskSnapshotInfo

                                                                                                                                            type DiskSnapshotInfo struct {
                                                                                                                                            
                                                                                                                                            	// The size of the disk in GB (e.g., 32).
                                                                                                                                            	SizeInGb *int32
                                                                                                                                            }

                                                                                                                                              Describes a disk snapshot.

                                                                                                                                              type DiskSnapshotState

                                                                                                                                              type DiskSnapshotState string
                                                                                                                                              const (
                                                                                                                                              	DiskSnapshotStatePending   DiskSnapshotState = "pending"
                                                                                                                                              	DiskSnapshotStateCompleted DiskSnapshotState = "completed"
                                                                                                                                              	DiskSnapshotStateError     DiskSnapshotState = "error"
                                                                                                                                              	DiskSnapshotStateUnknown   DiskSnapshotState = "unknown"
                                                                                                                                              )

                                                                                                                                                Enum values for DiskSnapshotState

                                                                                                                                                func (DiskSnapshotState) Values

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

                                                                                                                                                  type DiskState

                                                                                                                                                  type DiskState string
                                                                                                                                                  const (
                                                                                                                                                  	DiskStatePending   DiskState = "pending"
                                                                                                                                                  	DiskStateError     DiskState = "error"
                                                                                                                                                  	DiskStateAvailable DiskState = "available"
                                                                                                                                                  	DiskStateInUse     DiskState = "in-use"
                                                                                                                                                  	DiskStateUnknown   DiskState = "unknown"
                                                                                                                                                  )

                                                                                                                                                    Enum values for DiskState

                                                                                                                                                    func (DiskState) Values

                                                                                                                                                    func (DiskState) Values() []DiskState

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

                                                                                                                                                      type DistributionBundle

                                                                                                                                                      type DistributionBundle struct {
                                                                                                                                                      
                                                                                                                                                      	// The ID of the bundle.
                                                                                                                                                      	BundleId *string
                                                                                                                                                      
                                                                                                                                                      	// Indicates whether the bundle is active, and can be specified for a new
                                                                                                                                                      	// distribution.
                                                                                                                                                      	IsActive *bool
                                                                                                                                                      
                                                                                                                                                      	// The name of the distribution bundle.
                                                                                                                                                      	Name *string
                                                                                                                                                      
                                                                                                                                                      	// The monthly price, in US dollars, of the bundle.
                                                                                                                                                      	Price *float32
                                                                                                                                                      
                                                                                                                                                      	// The monthly network transfer quota of the bundle.
                                                                                                                                                      	TransferPerMonthInGb *int32
                                                                                                                                                      }

                                                                                                                                                        Describes the specifications of a distribution bundle.

                                                                                                                                                        type DistributionMetricName

                                                                                                                                                        type DistributionMetricName string
                                                                                                                                                        const (
                                                                                                                                                        	DistributionMetricNameRequests         DistributionMetricName = "Requests"
                                                                                                                                                        	DistributionMetricNameBytesDownloaded  DistributionMetricName = "BytesDownloaded"
                                                                                                                                                        	DistributionMetricNameBytesUploaded    DistributionMetricName = "BytesUploaded"
                                                                                                                                                        	DistributionMetricNameTotalErrorRate   DistributionMetricName = "TotalErrorRate"
                                                                                                                                                        	DistributionMetricNameHttp4xxErrorRate DistributionMetricName = "Http4xxErrorRate"
                                                                                                                                                        	DistributionMetricNameHttp5xxErrorRate DistributionMetricName = "Http5xxErrorRate"
                                                                                                                                                        )

                                                                                                                                                          Enum values for DistributionMetricName

                                                                                                                                                          func (DistributionMetricName) Values

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

                                                                                                                                                            type Domain

                                                                                                                                                            type Domain struct {
                                                                                                                                                            
                                                                                                                                                            	// The Amazon Resource Name (ARN) of the domain recordset (e.g.,
                                                                                                                                                            	// arn:aws:lightsail:global:123456789101:Domain/824cede0-abc7-4f84-8dbc-12345EXAMPLE).
                                                                                                                                                            	Arn *string
                                                                                                                                                            
                                                                                                                                                            	// The date when the domain recordset was created.
                                                                                                                                                            	CreatedAt *time.Time
                                                                                                                                                            
                                                                                                                                                            	// An array of key-value pairs containing information about the domain entries.
                                                                                                                                                            	DomainEntries []DomainEntry
                                                                                                                                                            
                                                                                                                                                            	// The AWS Region and Availability Zones where the domain recordset was created.
                                                                                                                                                            	Location *ResourceLocation
                                                                                                                                                            
                                                                                                                                                            	// The name of the domain.
                                                                                                                                                            	Name *string
                                                                                                                                                            
                                                                                                                                                            	// The resource type.
                                                                                                                                                            	ResourceType ResourceType
                                                                                                                                                            
                                                                                                                                                            	// The support code. Include this code in your email to support when you have
                                                                                                                                                            	// questions about an instance or another resource in Lightsail. This code enables
                                                                                                                                                            	// our support team to look up your Lightsail information more easily.
                                                                                                                                                            	SupportCode *string
                                                                                                                                                            
                                                                                                                                                            	// The tag keys and optional values for the resource. For more information about
                                                                                                                                                            	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                                                                                            	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                                                                                            	Tags []Tag
                                                                                                                                                            }

                                                                                                                                                              Describes a domain where you are storing recordsets in Lightsail.

                                                                                                                                                              type DomainEntry

                                                                                                                                                              type DomainEntry struct {
                                                                                                                                                              
                                                                                                                                                              	// The ID of the domain recordset entry.
                                                                                                                                                              	Id *string
                                                                                                                                                              
                                                                                                                                                              	// When true, specifies whether the domain entry is an alias used by the Lightsail
                                                                                                                                                              	// load balancer. You can include an alias (A type) record in your request, which
                                                                                                                                                              	// points to a load balancer DNS name and routes traffic to your load balancer.
                                                                                                                                                              	IsAlias *bool
                                                                                                                                                              
                                                                                                                                                              	// The name of the domain.
                                                                                                                                                              	Name *string
                                                                                                                                                              
                                                                                                                                                              	// (Deprecated) The options for the domain entry. In releases prior to November 29,
                                                                                                                                                              	// 2017, this parameter was not included in the API response. It is now deprecated.
                                                                                                                                                              	//
                                                                                                                                                              	// Deprecated: This member has been deprecated.
                                                                                                                                                              	Options map[string]string
                                                                                                                                                              
                                                                                                                                                              	// The target AWS name server (e.g., ns-111.awsdns-22.com.). For Lightsail load
                                                                                                                                                              	// balancers, the value looks like
                                                                                                                                                              	// ab1234c56789c6b86aba6fb203d443bc-123456789.us-east-2.elb.amazonaws.com. Be sure
                                                                                                                                                              	// to also set isAlias to true when setting up an A record for a load balancer.
                                                                                                                                                              	Target *string
                                                                                                                                                              
                                                                                                                                                              	// The type of domain entry, such as address (A), canonical name (CNAME), mail
                                                                                                                                                              	// exchanger (MX), name server (NS), start of authority (SOA), service locator
                                                                                                                                                              	// (SRV), or text (TXT). The following domain entry types can be used:
                                                                                                                                                              	//
                                                                                                                                                              	// * A
                                                                                                                                                              	//
                                                                                                                                                              	// *
                                                                                                                                                              	// CNAME
                                                                                                                                                              	//
                                                                                                                                                              	// * MX
                                                                                                                                                              	//
                                                                                                                                                              	// * NS
                                                                                                                                                              	//
                                                                                                                                                              	// * SOA
                                                                                                                                                              	//
                                                                                                                                                              	// * SRV
                                                                                                                                                              	//
                                                                                                                                                              	// * TXT
                                                                                                                                                              	Type *string
                                                                                                                                                              }

                                                                                                                                                                Describes a domain recordset entry.

                                                                                                                                                                type DomainValidationRecord

                                                                                                                                                                type DomainValidationRecord struct {
                                                                                                                                                                
                                                                                                                                                                	// The domain name of the certificate validation record. For example, example.com
                                                                                                                                                                	// or www.example.com.
                                                                                                                                                                	DomainName *string
                                                                                                                                                                
                                                                                                                                                                	// An object that describes the DNS records to add to your domain's DNS to validate
                                                                                                                                                                	// it for the certificate.
                                                                                                                                                                	ResourceRecord *ResourceRecord
                                                                                                                                                                }

                                                                                                                                                                  Describes the domain validation records of an Amazon Lightsail SSL/TLS certificate.

                                                                                                                                                                  type EndpointRequest

                                                                                                                                                                  type EndpointRequest struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The name of the container for the endpoint.
                                                                                                                                                                  	//
                                                                                                                                                                  	// This member is required.
                                                                                                                                                                  	ContainerName *string
                                                                                                                                                                  
                                                                                                                                                                  	// The port of the container to which traffic is forwarded to.
                                                                                                                                                                  	//
                                                                                                                                                                  	// This member is required.
                                                                                                                                                                  	ContainerPort *int32
                                                                                                                                                                  
                                                                                                                                                                  	// An object that describes the health check configuration of the container.
                                                                                                                                                                  	HealthCheck *ContainerServiceHealthCheckConfig
                                                                                                                                                                  }

                                                                                                                                                                    Describes the settings of a public endpoint for an Amazon Lightsail container service.

                                                                                                                                                                    type ExportSnapshotRecord

                                                                                                                                                                    type ExportSnapshotRecord struct {
                                                                                                                                                                    
                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the export snapshot record.
                                                                                                                                                                    	Arn *string
                                                                                                                                                                    
                                                                                                                                                                    	// The date when the export snapshot record was created.
                                                                                                                                                                    	CreatedAt *time.Time
                                                                                                                                                                    
                                                                                                                                                                    	// A list of objects describing the destination of the export snapshot record.
                                                                                                                                                                    	DestinationInfo *DestinationInfo
                                                                                                                                                                    
                                                                                                                                                                    	// The AWS Region and Availability Zone where the export snapshot record is
                                                                                                                                                                    	// located.
                                                                                                                                                                    	Location *ResourceLocation
                                                                                                                                                                    
                                                                                                                                                                    	// The export snapshot record name.
                                                                                                                                                                    	Name *string
                                                                                                                                                                    
                                                                                                                                                                    	// The Lightsail resource type (e.g., ExportSnapshotRecord).
                                                                                                                                                                    	ResourceType ResourceType
                                                                                                                                                                    
                                                                                                                                                                    	// A list of objects describing the source of the export snapshot record.
                                                                                                                                                                    	SourceInfo *ExportSnapshotRecordSourceInfo
                                                                                                                                                                    
                                                                                                                                                                    	// The state of the export snapshot record.
                                                                                                                                                                    	State RecordState
                                                                                                                                                                    }

                                                                                                                                                                      Describes an export snapshot record.

                                                                                                                                                                      type ExportSnapshotRecordSourceInfo

                                                                                                                                                                      type ExportSnapshotRecordSourceInfo struct {
                                                                                                                                                                      
                                                                                                                                                                      	// The Amazon Resource Name (ARN) of the source instance or disk snapshot.
                                                                                                                                                                      	Arn *string
                                                                                                                                                                      
                                                                                                                                                                      	// The date when the source instance or disk snapshot was created.
                                                                                                                                                                      	CreatedAt *time.Time
                                                                                                                                                                      
                                                                                                                                                                      	// A list of objects describing a disk snapshot.
                                                                                                                                                                      	DiskSnapshotInfo *DiskSnapshotInfo
                                                                                                                                                                      
                                                                                                                                                                      	// The Amazon Resource Name (ARN) of the snapshot's source instance or disk.
                                                                                                                                                                      	FromResourceArn *string
                                                                                                                                                                      
                                                                                                                                                                      	// The name of the snapshot's source instance or disk.
                                                                                                                                                                      	FromResourceName *string
                                                                                                                                                                      
                                                                                                                                                                      	// A list of objects describing an instance snapshot.
                                                                                                                                                                      	InstanceSnapshotInfo *InstanceSnapshotInfo
                                                                                                                                                                      
                                                                                                                                                                      	// The name of the source instance or disk snapshot.
                                                                                                                                                                      	Name *string
                                                                                                                                                                      
                                                                                                                                                                      	// The Lightsail resource type (e.g., InstanceSnapshot or DiskSnapshot).
                                                                                                                                                                      	ResourceType ExportSnapshotRecordSourceType
                                                                                                                                                                      }

                                                                                                                                                                        Describes the source of an export snapshot record.

                                                                                                                                                                        type ExportSnapshotRecordSourceType

                                                                                                                                                                        type ExportSnapshotRecordSourceType string
                                                                                                                                                                        const (
                                                                                                                                                                        	ExportSnapshotRecordSourceTypeInstanceSnapshot ExportSnapshotRecordSourceType = "InstanceSnapshot"
                                                                                                                                                                        	ExportSnapshotRecordSourceTypeDiskSnapshot     ExportSnapshotRecordSourceType = "DiskSnapshot"
                                                                                                                                                                        )

                                                                                                                                                                          Enum values for ExportSnapshotRecordSourceType

                                                                                                                                                                          func (ExportSnapshotRecordSourceType) Values

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

                                                                                                                                                                            type ForwardValues

                                                                                                                                                                            type ForwardValues string
                                                                                                                                                                            const (
                                                                                                                                                                            	ForwardValuesNone      ForwardValues = "none"
                                                                                                                                                                            	ForwardValuesAllowList ForwardValues = "allow-list"
                                                                                                                                                                            	ForwardValuesAll       ForwardValues = "all"
                                                                                                                                                                            )

                                                                                                                                                                              Enum values for ForwardValues

                                                                                                                                                                              func (ForwardValues) Values

                                                                                                                                                                              func (ForwardValues) Values() []ForwardValues

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

                                                                                                                                                                                type HeaderEnum

                                                                                                                                                                                type HeaderEnum string
                                                                                                                                                                                const (
                                                                                                                                                                                	HeaderEnumAccept                    HeaderEnum = "Accept"
                                                                                                                                                                                	HeaderEnumAcceptCharset             HeaderEnum = "Accept-Charset"
                                                                                                                                                                                	HeaderEnumAcceptDatetime            HeaderEnum = "Accept-Datetime"
                                                                                                                                                                                	HeaderEnumAcceptEncoding            HeaderEnum = "Accept-Encoding"
                                                                                                                                                                                	HeaderEnumAcceptLanguage            HeaderEnum = "Accept-Language"
                                                                                                                                                                                	HeaderEnumAuthorization             HeaderEnum = "Authorization"
                                                                                                                                                                                	HeaderEnumCloudFrontForwardedProto  HeaderEnum = "CloudFront-Forwarded-Proto"
                                                                                                                                                                                	HeaderEnumCloudFrontIsDesktopViewer HeaderEnum = "CloudFront-Is-Desktop-Viewer"
                                                                                                                                                                                	HeaderEnumCloudFrontIsMobileViewer  HeaderEnum = "CloudFront-Is-Mobile-Viewer"
                                                                                                                                                                                	HeaderEnumCloudFrontIsSmartTVViewer HeaderEnum = "CloudFront-Is-SmartTV-Viewer"
                                                                                                                                                                                	HeaderEnumCloudFrontIsTabletViewer  HeaderEnum = "CloudFront-Is-Tablet-Viewer"
                                                                                                                                                                                	HeaderEnumCloudFrontViewerCountry   HeaderEnum = "CloudFront-Viewer-Country"
                                                                                                                                                                                	HeaderEnumHost                      HeaderEnum = "Host"
                                                                                                                                                                                	HeaderEnumOrigin                    HeaderEnum = "Origin"
                                                                                                                                                                                	HeaderEnumReferer                   HeaderEnum = "Referer"
                                                                                                                                                                                )

                                                                                                                                                                                  Enum values for HeaderEnum

                                                                                                                                                                                  func (HeaderEnum) Values

                                                                                                                                                                                  func (HeaderEnum) Values() []HeaderEnum

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

                                                                                                                                                                                    type HeaderObject

                                                                                                                                                                                    type HeaderObject struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The specific headers to forward to your distribution's origin.
                                                                                                                                                                                    	HeadersAllowList []HeaderEnum
                                                                                                                                                                                    
                                                                                                                                                                                    	// The headers that you want your distribution to forward to your origin and base
                                                                                                                                                                                    	// caching on. You can configure your distribution to do one of the following:
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// *
                                                                                                                                                                                    	// all - Forward all headers to your origin.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// * none - Forward only the default
                                                                                                                                                                                    	// headers.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// * allow-list - Forward only the headers you specify using the
                                                                                                                                                                                    	// headersAllowList parameter.
                                                                                                                                                                                    	Option ForwardValues
                                                                                                                                                                                    }

                                                                                                                                                                                      Describes the request headers that a Lightsail distribution bases caching on. For the headers that you specify, your distribution caches separate versions of the specified content based on the header values in viewer requests. For example, suppose viewer requests for logo.jpg contain a custom product header that has a value of either acme or apex, and you configure your distribution to cache your content based on values in the product header. Your distribution forwards the product header to the origin and caches the response from the origin once for each header value.

                                                                                                                                                                                      type HostKeyAttributes

                                                                                                                                                                                      type HostKeyAttributes struct {
                                                                                                                                                                                      
                                                                                                                                                                                      	// The SSH host key algorithm or the RDP certificate format. For SSH host keys, the
                                                                                                                                                                                      	// algorithm may be ssh-rsa, ecdsa-sha2-nistp256, ssh-ed25519, etc. For RDP
                                                                                                                                                                                      	// certificates, the algorithm is always x509-cert.
                                                                                                                                                                                      	Algorithm *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// The SHA-1 fingerprint of the returned SSH host key or RDP certificate.
                                                                                                                                                                                      	//
                                                                                                                                                                                      	// *
                                                                                                                                                                                      	// Example of an SHA-1 SSH fingerprint: SHA1:1CHH6FaAaXjtFOsR/t83vf91SR0
                                                                                                                                                                                      	//
                                                                                                                                                                                      	// * Example
                                                                                                                                                                                      	// of an SHA-1 RDP fingerprint:
                                                                                                                                                                                      	// af:34:51:fe:09:f0:e0:da:b8:4e:56:ca:60:c2:10:ff:38:06:db:45
                                                                                                                                                                                      	FingerprintSHA1 *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// The SHA-256 fingerprint of the returned SSH host key or RDP certificate.
                                                                                                                                                                                      	//
                                                                                                                                                                                      	// *
                                                                                                                                                                                      	// Example of an SHA-256 SSH fingerprint:
                                                                                                                                                                                      	// SHA256:KTsMnRBh1IhD17HpdfsbzeGA4jOijm5tyXsMjKVbB8o
                                                                                                                                                                                      	//
                                                                                                                                                                                      	// * Example of an SHA-256 RDP
                                                                                                                                                                                      	// fingerprint:
                                                                                                                                                                                      	// 03:9b:36:9f:4b:de:4e:61:70:fc:7c:c9:78:e7:d2:1a:1c:25:a8:0c:91:f6:7c:e4:d6:a0:85:c8:b4:53:99:68
                                                                                                                                                                                      	FingerprintSHA256 *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// The returned RDP certificate is not valid after this point in time. This value
                                                                                                                                                                                      	// is listed only for RDP certificates.
                                                                                                                                                                                      	NotValidAfter *time.Time
                                                                                                                                                                                      
                                                                                                                                                                                      	// The returned RDP certificate is valid after this point in time. This value is
                                                                                                                                                                                      	// listed only for RDP certificates.
                                                                                                                                                                                      	NotValidBefore *time.Time
                                                                                                                                                                                      
                                                                                                                                                                                      	// The public SSH host key or the RDP certificate.
                                                                                                                                                                                      	PublicKey *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// The time that the SSH host key or RDP certificate was recorded by Lightsail.
                                                                                                                                                                                      	WitnessedAt *time.Time
                                                                                                                                                                                      }

                                                                                                                                                                                        Describes the public SSH host keys or the RDP certificate.

                                                                                                                                                                                        type InputOrigin

                                                                                                                                                                                        type InputOrigin struct {
                                                                                                                                                                                        
                                                                                                                                                                                        	// The name of the origin resource.
                                                                                                                                                                                        	Name *string
                                                                                                                                                                                        
                                                                                                                                                                                        	// The protocol that your Amazon Lightsail distribution uses when establishing a
                                                                                                                                                                                        	// connection with your origin to pull content.
                                                                                                                                                                                        	ProtocolPolicy OriginProtocolPolicyEnum
                                                                                                                                                                                        
                                                                                                                                                                                        	// The AWS Region name of the origin resource.
                                                                                                                                                                                        	RegionName RegionName
                                                                                                                                                                                        }

                                                                                                                                                                                          Describes the origin resource of an Amazon Lightsail content delivery network (CDN) distribution. An origin can be a Lightsail instance or load balancer. A distribution pulls content from an origin, caches it, and serves it to viewers via a worldwide network of edge servers.

                                                                                                                                                                                          type Instance

                                                                                                                                                                                          type Instance struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// An array of objects representing the add-ons enabled on the instance.
                                                                                                                                                                                          	AddOns []AddOn
                                                                                                                                                                                          
                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the instance (e.g.,
                                                                                                                                                                                          	// arn:aws:lightsail:us-east-2:123456789101:Instance/244ad76f-8aad-4741-809f-12345EXAMPLE).
                                                                                                                                                                                          	Arn *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The blueprint ID (e.g., os_amlinux_2016_03).
                                                                                                                                                                                          	BlueprintId *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The friendly name of the blueprint (e.g., Amazon Linux).
                                                                                                                                                                                          	BlueprintName *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The bundle for the instance (e.g., micro_1_0).
                                                                                                                                                                                          	BundleId *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The timestamp when the instance was created (e.g., 1479734909.17) in Unix time
                                                                                                                                                                                          	// format.
                                                                                                                                                                                          	CreatedAt *time.Time
                                                                                                                                                                                          
                                                                                                                                                                                          	// The size of the vCPU and the amount of RAM for the instance.
                                                                                                                                                                                          	Hardware *InstanceHardware
                                                                                                                                                                                          
                                                                                                                                                                                          	// The IPv6 address of the instance.
                                                                                                                                                                                          	Ipv6Address *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// A Boolean value indicating whether this instance has a static IP assigned to it.
                                                                                                                                                                                          	IsStaticIp *bool
                                                                                                                                                                                          
                                                                                                                                                                                          	// The region name and Availability Zone where the instance is located.
                                                                                                                                                                                          	Location *ResourceLocation
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name the user gave the instance (e.g., Amazon_Linux-1GB-Ohio-1).
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Information about the public ports and monthly data transfer rates for the
                                                                                                                                                                                          	// instance.
                                                                                                                                                                                          	Networking *InstanceNetworking
                                                                                                                                                                                          
                                                                                                                                                                                          	// The private IP address of the instance.
                                                                                                                                                                                          	PrivateIpAddress *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The public IP address of the instance.
                                                                                                                                                                                          	PublicIpAddress *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The type of resource (usually Instance).
                                                                                                                                                                                          	ResourceType ResourceType
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the SSH key being used to connect to the instance (e.g.,
                                                                                                                                                                                          	// LightsailDefaultKeyPair).
                                                                                                                                                                                          	SshKeyName *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The status code and the state (e.g., running) for the instance.
                                                                                                                                                                                          	State *InstanceState
                                                                                                                                                                                          
                                                                                                                                                                                          	// The support code. Include this code in your email to support when you have
                                                                                                                                                                                          	// questions about an instance or another resource in Lightsail. This code enables
                                                                                                                                                                                          	// our support team to look up your Lightsail information more easily.
                                                                                                                                                                                          	SupportCode *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The tag keys and optional values for the resource. For more information about
                                                                                                                                                                                          	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                                                                                                                          	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                                                                                                                          	Tags []Tag
                                                                                                                                                                                          
                                                                                                                                                                                          	// The user name for connecting to the instance (e.g., ec2-user).
                                                                                                                                                                                          	Username *string
                                                                                                                                                                                          }

                                                                                                                                                                                            Describes an instance (a virtual private server).

                                                                                                                                                                                            type InstanceAccessDetails

                                                                                                                                                                                            type InstanceAccessDetails struct {
                                                                                                                                                                                            
                                                                                                                                                                                            	// For SSH access, the public key to use when accessing your instance For OpenSSH
                                                                                                                                                                                            	// clients (e.g., command line SSH), you should save this value to
                                                                                                                                                                                            	// tempkey-cert.pub.
                                                                                                                                                                                            	CertKey *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// For SSH access, the date on which the temporary keys expire.
                                                                                                                                                                                            	ExpiresAt *time.Time
                                                                                                                                                                                            
                                                                                                                                                                                            	// Describes the public SSH host keys or the RDP certificate.
                                                                                                                                                                                            	HostKeys []HostKeyAttributes
                                                                                                                                                                                            
                                                                                                                                                                                            	// The name of this Amazon Lightsail instance.
                                                                                                                                                                                            	InstanceName *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The public IP address of the Amazon Lightsail instance.
                                                                                                                                                                                            	IpAddress *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// For RDP access, the password for your Amazon Lightsail instance. Password will
                                                                                                                                                                                            	// be an empty string if the password for your new instance is not ready yet. When
                                                                                                                                                                                            	// you create an instance, it can take up to 15 minutes for the instance to be
                                                                                                                                                                                            	// ready. If you create an instance using any key pair other than the default
                                                                                                                                                                                            	// (LightsailDefaultKeyPair), password will always be an empty string. If you
                                                                                                                                                                                            	// change the Administrator password on the instance, Lightsail will continue to
                                                                                                                                                                                            	// return the original password value. When accessing the instance using RDP, you
                                                                                                                                                                                            	// need to manually enter the Administrator password after changing it from the
                                                                                                                                                                                            	// default.
                                                                                                                                                                                            	Password *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// For a Windows Server-based instance, an object with the data you can use to
                                                                                                                                                                                            	// retrieve your password. This is only needed if password is empty and the
                                                                                                                                                                                            	// instance is not new (and therefore the password is not ready yet). When you
                                                                                                                                                                                            	// create an instance, it can take up to 15 minutes for the instance to be ready.
                                                                                                                                                                                            	PasswordData *PasswordData
                                                                                                                                                                                            
                                                                                                                                                                                            	// For SSH access, the temporary private key. For OpenSSH clients (e.g., command
                                                                                                                                                                                            	// line SSH), you should save this value to tempkey).
                                                                                                                                                                                            	PrivateKey *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The protocol for these Amazon Lightsail instance access details.
                                                                                                                                                                                            	Protocol InstanceAccessProtocol
                                                                                                                                                                                            
                                                                                                                                                                                            	// The user name to use when logging in to the Amazon Lightsail instance.
                                                                                                                                                                                            	Username *string
                                                                                                                                                                                            }

                                                                                                                                                                                              The parameters for gaining temporary access to one of your Amazon Lightsail instances.

                                                                                                                                                                                              type InstanceAccessProtocol

                                                                                                                                                                                              type InstanceAccessProtocol string
                                                                                                                                                                                              const (
                                                                                                                                                                                              	InstanceAccessProtocolSsh InstanceAccessProtocol = "ssh"
                                                                                                                                                                                              	InstanceAccessProtocolRdp InstanceAccessProtocol = "rdp"
                                                                                                                                                                                              )

                                                                                                                                                                                                Enum values for InstanceAccessProtocol

                                                                                                                                                                                                func (InstanceAccessProtocol) Values

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

                                                                                                                                                                                                  type InstanceEntry

                                                                                                                                                                                                  type InstanceEntry struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The Availability Zone for the new Amazon EC2 instance.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	AvailabilityZone *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The instance type (e.g., t2.micro) to use for the new Amazon EC2 instance.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	InstanceType *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The port configuration to use for the new Amazon EC2 instance. The following
                                                                                                                                                                                                  	// configuration options are available:
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// * DEFAULT - Use the default firewall
                                                                                                                                                                                                  	// settings from the Lightsail instance blueprint.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// * INSTANCE - Use the configured
                                                                                                                                                                                                  	// firewall settings from the source Lightsail instance.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// * NONE - Use the default
                                                                                                                                                                                                  	// Amazon EC2 security group.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// * CLOSED - All ports closed.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// If you configured
                                                                                                                                                                                                  	// lightsail-connect as a cidrListAliases on your instance, or if you chose to
                                                                                                                                                                                                  	// allow the Lightsail browser-based SSH or RDP clients to connect to your
                                                                                                                                                                                                  	// instance, that configuration is not carried over to your new Amazon EC2
                                                                                                                                                                                                  	// instance.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	PortInfoSource PortInfoSourceType
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The name of the export snapshot record, which contains the exported Lightsail
                                                                                                                                                                                                  	// instance snapshot that will be used as the source of the new Amazon EC2
                                                                                                                                                                                                  	// instance. Use the get export snapshot records operation to get a list of export
                                                                                                                                                                                                  	// snapshot records that you can use to create a CloudFormation stack.
                                                                                                                                                                                                  	//
                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                  	SourceName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// A launch script you can create that configures a server with additional user
                                                                                                                                                                                                  	// data. For example, you might want to run apt-get -y update. Depending on the
                                                                                                                                                                                                  	// machine image you choose, the command to get software on your instance varies.
                                                                                                                                                                                                  	// Amazon Linux and CentOS use yum, Debian and Ubuntu use apt-get, and FreeBSD uses
                                                                                                                                                                                                  	// pkg.
                                                                                                                                                                                                  	UserData *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                    Describes the Amazon Elastic Compute Cloud instance and related resources to be created using the create cloud formation stack operation.

                                                                                                                                                                                                    type InstanceHardware

                                                                                                                                                                                                    type InstanceHardware struct {
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The number of vCPUs the instance has.
                                                                                                                                                                                                    	CpuCount *int32
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The disks attached to the instance.
                                                                                                                                                                                                    	Disks []Disk
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The amount of RAM in GB on the instance (e.g., 1.0).
                                                                                                                                                                                                    	RamSizeInGb *float32
                                                                                                                                                                                                    }

                                                                                                                                                                                                      Describes the hardware for the instance.

                                                                                                                                                                                                      type InstanceHealthReason

                                                                                                                                                                                                      type InstanceHealthReason string
                                                                                                                                                                                                      const (
                                                                                                                                                                                                      	InstanceHealthReasonLbRegistrationInProgress         InstanceHealthReason = "Lb.RegistrationInProgress"
                                                                                                                                                                                                      	InstanceHealthReasonLbInitialHealthChecking          InstanceHealthReason = "Lb.InitialHealthChecking"
                                                                                                                                                                                                      	InstanceHealthReasonLbInternalError                  InstanceHealthReason = "Lb.InternalError"
                                                                                                                                                                                                      	InstanceHealthReasonInstanceResponseCodeMismatch     InstanceHealthReason = "Instance.ResponseCodeMismatch"
                                                                                                                                                                                                      	InstanceHealthReasonInstanceTimeout                  InstanceHealthReason = "Instance.Timeout"
                                                                                                                                                                                                      	InstanceHealthReasonInstanceFailedHealthChecks       InstanceHealthReason = "Instance.FailedHealthChecks"
                                                                                                                                                                                                      	InstanceHealthReasonInstanceNotRegistered            InstanceHealthReason = "Instance.NotRegistered"
                                                                                                                                                                                                      	InstanceHealthReasonInstanceNotInUse                 InstanceHealthReason = "Instance.NotInUse"
                                                                                                                                                                                                      	InstanceHealthReasonInstanceDeregistrationInProgress InstanceHealthReason = "Instance.DeregistrationInProgress"
                                                                                                                                                                                                      	InstanceHealthReasonInstanceInvalidState             InstanceHealthReason = "Instance.InvalidState"
                                                                                                                                                                                                      	InstanceHealthReasonInstanceIpUnusable               InstanceHealthReason = "Instance.IpUnusable"
                                                                                                                                                                                                      )

                                                                                                                                                                                                        Enum values for InstanceHealthReason

                                                                                                                                                                                                        func (InstanceHealthReason) Values

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

                                                                                                                                                                                                          type InstanceHealthState

                                                                                                                                                                                                          type InstanceHealthState string
                                                                                                                                                                                                          const (
                                                                                                                                                                                                          	InstanceHealthStateInitial     InstanceHealthState = "initial"
                                                                                                                                                                                                          	InstanceHealthStateHealthy     InstanceHealthState = "healthy"
                                                                                                                                                                                                          	InstanceHealthStateUnhealthy   InstanceHealthState = "unhealthy"
                                                                                                                                                                                                          	InstanceHealthStateUnused      InstanceHealthState = "unused"
                                                                                                                                                                                                          	InstanceHealthStateDraining    InstanceHealthState = "draining"
                                                                                                                                                                                                          	InstanceHealthStateUnavailable InstanceHealthState = "unavailable"
                                                                                                                                                                                                          )

                                                                                                                                                                                                            Enum values for InstanceHealthState

                                                                                                                                                                                                            func (InstanceHealthState) Values

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

                                                                                                                                                                                                              type InstanceHealthSummary

                                                                                                                                                                                                              type InstanceHealthSummary struct {
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Describes the overall instance health. Valid values are below.
                                                                                                                                                                                                              	InstanceHealth InstanceHealthState
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// More information about the instance health. If the instanceHealth is healthy,
                                                                                                                                                                                                              	// then an instanceHealthReason value is not provided. If instanceHealth is
                                                                                                                                                                                                              	// initial, the instanceHealthReason value can be one of the following:
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// *
                                                                                                                                                                                                              	// Lb.RegistrationInProgress - The target instance is in the process of being
                                                                                                                                                                                                              	// registered with the load balancer.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// * Lb.InitialHealthChecking - The Lightsail
                                                                                                                                                                                                              	// load balancer is still sending the target instance the minimum number of health
                                                                                                                                                                                                              	// checks required to determine its health status.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// If instanceHealth is unhealthy,
                                                                                                                                                                                                              	// the instanceHealthReason value can be one of the following:
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// *
                                                                                                                                                                                                              	// Instance.ResponseCodeMismatch - The health checks did not return an expected
                                                                                                                                                                                                              	// HTTP code.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// * Instance.Timeout - The health check requests timed out.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// *
                                                                                                                                                                                                              	// Instance.FailedHealthChecks - The health checks failed because the connection to
                                                                                                                                                                                                              	// the target instance timed out, the target instance response was malformed, or
                                                                                                                                                                                                              	// the target instance failed the health check for an unknown reason.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// *
                                                                                                                                                                                                              	// Lb.InternalError - The health checks failed due to an internal error.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// If
                                                                                                                                                                                                              	// instanceHealth is unused, the instanceHealthReason value can be one of the
                                                                                                                                                                                                              	// following:
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// * Instance.NotRegistered - The target instance is not registered
                                                                                                                                                                                                              	// with the target group.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// * Instance.NotInUse - The target group is not used by
                                                                                                                                                                                                              	// any load balancer, or the target instance is in an Availability Zone that is not
                                                                                                                                                                                                              	// enabled for its load balancer.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// * Instance.IpUnusable - The target IP address is
                                                                                                                                                                                                              	// reserved for use by a Lightsail load balancer.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// * Instance.InvalidState - The
                                                                                                                                                                                                              	// target is in the stopped or terminated state.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// If instanceHealth is draining,
                                                                                                                                                                                                              	// the instanceHealthReason value can be one of the following:
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// *
                                                                                                                                                                                                              	// Instance.DeregistrationInProgress - The target instance is in the process of
                                                                                                                                                                                                              	// being deregistered and the deregistration delay period has not expired.
                                                                                                                                                                                                              	InstanceHealthReason InstanceHealthReason
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// The name of the Lightsail instance for which you are requesting health check
                                                                                                                                                                                                              	// data.
                                                                                                                                                                                                              	InstanceName *string
                                                                                                                                                                                                              }

                                                                                                                                                                                                                Describes information about the health of the instance.

                                                                                                                                                                                                                type InstanceMetricName

                                                                                                                                                                                                                type InstanceMetricName string
                                                                                                                                                                                                                const (
                                                                                                                                                                                                                	InstanceMetricNameCPUUtilization            InstanceMetricName = "CPUUtilization"
                                                                                                                                                                                                                	InstanceMetricNameNetworkIn                 InstanceMetricName = "NetworkIn"
                                                                                                                                                                                                                	InstanceMetricNameNetworkOut                InstanceMetricName = "NetworkOut"
                                                                                                                                                                                                                	InstanceMetricNameStatusCheckFailed         InstanceMetricName = "StatusCheckFailed"
                                                                                                                                                                                                                	InstanceMetricNameStatusCheckFailedInstance InstanceMetricName = "StatusCheckFailed_Instance"
                                                                                                                                                                                                                	InstanceMetricNameStatusCheckFailedSystem   InstanceMetricName = "StatusCheckFailed_System"
                                                                                                                                                                                                                	InstanceMetricNameBurstCapacityTime         InstanceMetricName = "BurstCapacityTime"
                                                                                                                                                                                                                	InstanceMetricNameBurstCapacityPercentage   InstanceMetricName = "BurstCapacityPercentage"
                                                                                                                                                                                                                )

                                                                                                                                                                                                                  Enum values for InstanceMetricName

                                                                                                                                                                                                                  func (InstanceMetricName) Values

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

                                                                                                                                                                                                                    type InstanceNetworking

                                                                                                                                                                                                                    type InstanceNetworking struct {
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The amount of data in GB allocated for monthly data transfers.
                                                                                                                                                                                                                    	MonthlyTransfer *MonthlyTransfer
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// An array of key-value pairs containing information about the ports on the
                                                                                                                                                                                                                    	// instance.
                                                                                                                                                                                                                    	Ports []InstancePortInfo
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      Describes monthly data transfer rates and port information for an instance.

                                                                                                                                                                                                                      type InstancePlatform

                                                                                                                                                                                                                      type InstancePlatform string
                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                      	InstancePlatformLinuxUnix InstancePlatform = "LINUX_UNIX"
                                                                                                                                                                                                                      	InstancePlatformWindows   InstancePlatform = "WINDOWS"
                                                                                                                                                                                                                      )

                                                                                                                                                                                                                        Enum values for InstancePlatform

                                                                                                                                                                                                                        func (InstancePlatform) Values

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

                                                                                                                                                                                                                          type InstancePortInfo

                                                                                                                                                                                                                          type InstancePortInfo struct {
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The access direction (inbound or outbound). Lightsail currently supports only
                                                                                                                                                                                                                          	// inbound access direction.
                                                                                                                                                                                                                          	AccessDirection AccessDirection
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The location from which access is allowed. For example, Anywhere (0.0.0.0/0), or
                                                                                                                                                                                                                          	// Custom if a specific IP address or range of IP addresses is allowed.
                                                                                                                                                                                                                          	AccessFrom *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The type of access (Public or Private).
                                                                                                                                                                                                                          	AccessType PortAccessType
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// An alias that defines access for a preconfigured range of IP addresses. The only
                                                                                                                                                                                                                          	// alias currently supported is lightsail-connect, which allows IP addresses of the
                                                                                                                                                                                                                          	// browser-based RDP/SSH client in the Lightsail console to connect to your
                                                                                                                                                                                                                          	// instance.
                                                                                                                                                                                                                          	CidrListAliases []string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The IP address, or range of IP addresses in CIDR notation, that are allowed to
                                                                                                                                                                                                                          	// connect to an instance through the ports, and the protocol. Lightsail supports
                                                                                                                                                                                                                          	// IPv4 addresses. For more information about CIDR block notation, see Classless
                                                                                                                                                                                                                          	// Inter-Domain Routing
                                                                                                                                                                                                                          	// (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) on
                                                                                                                                                                                                                          	// Wikipedia.
                                                                                                                                                                                                                          	Cidrs []string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The common name of the port information.
                                                                                                                                                                                                                          	CommonName *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The first port in a range of open ports on an instance. Allowed ports:
                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                          	// * TCP
                                                                                                                                                                                                                          	// and UDP - 0 to 65535
                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                          	// * ICMP - The ICMP type. For example, specify 8 as the
                                                                                                                                                                                                                          	// fromPort (ICMP type), and -1 as the toPort (ICMP code), to enable ICMP Ping. For
                                                                                                                                                                                                                          	// more information, see Control Messages
                                                                                                                                                                                                                          	// (https://en.wikipedia.org/wiki/Internet_Control_Message_Protocol#Control_messages)
                                                                                                                                                                                                                          	// on Wikipedia.
                                                                                                                                                                                                                          	FromPort int32
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The IP protocol name. The name can be one of the following:
                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                          	// * tcp -
                                                                                                                                                                                                                          	// Transmission Control Protocol (TCP) provides reliable, ordered, and
                                                                                                                                                                                                                          	// error-checked delivery of streamed data between applications running on hosts
                                                                                                                                                                                                                          	// communicating by an IP network. If you have an application that doesn't require
                                                                                                                                                                                                                          	// reliable data stream service, use UDP instead.
                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                          	// * all - All transport layer
                                                                                                                                                                                                                          	// protocol types. For more general information, see Transport layer
                                                                                                                                                                                                                          	// (https://en.wikipedia.org/wiki/Transport_layer) on Wikipedia.
                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                          	// * udp - With User
                                                                                                                                                                                                                          	// Datagram Protocol (UDP), computer applications can send messages (or datagrams)
                                                                                                                                                                                                                          	// to other hosts on an Internet Protocol (IP) network. Prior communications are
                                                                                                                                                                                                                          	// not required to set up transmission channels or data paths. Applications that
                                                                                                                                                                                                                          	// don't require reliable data stream service can use UDP, which provides a
                                                                                                                                                                                                                          	// connectionless datagram service that emphasizes reduced latency over
                                                                                                                                                                                                                          	// reliability. If you do require reliable data stream service, use TCP instead.
                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                          	// *
                                                                                                                                                                                                                          	// icmp - Internet Control Message Protocol (ICMP) is used to send error messages
                                                                                                                                                                                                                          	// and operational information indicating success or failure when communicating
                                                                                                                                                                                                                          	// with an instance. For example, an error is indicated when an instance could not
                                                                                                                                                                                                                          	// be reached. When you specify icmp as the protocol, you must specify the ICMP
                                                                                                                                                                                                                          	// type using the fromPort parameter, and ICMP code using the toPort parameter.
                                                                                                                                                                                                                          	Protocol NetworkProtocol
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The last port in a range of open ports on an instance. Allowed ports:
                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                          	// * TCP and
                                                                                                                                                                                                                          	// UDP - 0 to 65535
                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                          	// * ICMP - The ICMP code. For example, specify 8 as the fromPort
                                                                                                                                                                                                                          	// (ICMP type), and -1 as the toPort (ICMP code), to enable ICMP Ping. For more
                                                                                                                                                                                                                          	// information, see Control Messages
                                                                                                                                                                                                                          	// (https://en.wikipedia.org/wiki/Internet_Control_Message_Protocol#Control_messages)
                                                                                                                                                                                                                          	// on Wikipedia.
                                                                                                                                                                                                                          	ToPort int32
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            Describes information about ports for an Amazon Lightsail instance.

                                                                                                                                                                                                                            type InstancePortState

                                                                                                                                                                                                                            type InstancePortState struct {
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// An alias that defines access for a preconfigured range of IP addresses. The only
                                                                                                                                                                                                                            	// alias currently supported is lightsail-connect, which allows IP addresses of the
                                                                                                                                                                                                                            	// browser-based RDP/SSH client in the Lightsail console to connect to your
                                                                                                                                                                                                                            	// instance.
                                                                                                                                                                                                                            	CidrListAliases []string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The IP address, or range of IP addresses in CIDR notation, that are allowed to
                                                                                                                                                                                                                            	// connect to an instance through the ports, and the protocol. Lightsail supports
                                                                                                                                                                                                                            	// IPv4 addresses. For more information about CIDR block notation, see Classless
                                                                                                                                                                                                                            	// Inter-Domain Routing
                                                                                                                                                                                                                            	// (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) on
                                                                                                                                                                                                                            	// Wikipedia.
                                                                                                                                                                                                                            	Cidrs []string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The first port in a range of open ports on an instance. Allowed ports:
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// * TCP
                                                                                                                                                                                                                            	// and UDP - 0 to 65535
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// * ICMP - The ICMP type. For example, specify 8 as the
                                                                                                                                                                                                                            	// fromPort (ICMP type), and -1 as the toPort (ICMP code), to enable ICMP Ping. For
                                                                                                                                                                                                                            	// more information, see Control Messages
                                                                                                                                                                                                                            	// (https://en.wikipedia.org/wiki/Internet_Control_Message_Protocol#Control_messages)
                                                                                                                                                                                                                            	// on Wikipedia.
                                                                                                                                                                                                                            	FromPort int32
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The IP protocol name. The name can be one of the following:
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// * tcp -
                                                                                                                                                                                                                            	// Transmission Control Protocol (TCP) provides reliable, ordered, and
                                                                                                                                                                                                                            	// error-checked delivery of streamed data between applications running on hosts
                                                                                                                                                                                                                            	// communicating by an IP network. If you have an application that doesn't require
                                                                                                                                                                                                                            	// reliable data stream service, use UDP instead.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// * all - All transport layer
                                                                                                                                                                                                                            	// protocol types. For more general information, see Transport layer
                                                                                                                                                                                                                            	// (https://en.wikipedia.org/wiki/Transport_layer) on Wikipedia.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// * udp - With User
                                                                                                                                                                                                                            	// Datagram Protocol (UDP), computer applications can send messages (or datagrams)
                                                                                                                                                                                                                            	// to other hosts on an Internet Protocol (IP) network. Prior communications are
                                                                                                                                                                                                                            	// not required to set up transmission channels or data paths. Applications that
                                                                                                                                                                                                                            	// don't require reliable data stream service can use UDP, which provides a
                                                                                                                                                                                                                            	// connectionless datagram service that emphasizes reduced latency over
                                                                                                                                                                                                                            	// reliability. If you do require reliable data stream service, use TCP instead.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// *
                                                                                                                                                                                                                            	// icmp - Internet Control Message Protocol (ICMP) is used to send error messages
                                                                                                                                                                                                                            	// and operational information indicating success or failure when communicating
                                                                                                                                                                                                                            	// with an instance. For example, an error is indicated when an instance could not
                                                                                                                                                                                                                            	// be reached. When you specify icmp as the protocol, you must specify the ICMP
                                                                                                                                                                                                                            	// type using the fromPort parameter, and ICMP code using the toPort parameter.
                                                                                                                                                                                                                            	Protocol NetworkProtocol
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Specifies whether the instance port is open or closed. The port state for
                                                                                                                                                                                                                            	// Lightsail instances is always open.
                                                                                                                                                                                                                            	State PortState
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The last port in a range of open ports on an instance. Allowed ports:
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// * TCP and
                                                                                                                                                                                                                            	// UDP - 0 to 65535
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// * ICMP - The ICMP code. For example, specify 8 as the fromPort
                                                                                                                                                                                                                            	// (ICMP type), and -1 as the toPort (ICMP code), to enable ICMP Ping. For more
                                                                                                                                                                                                                            	// information, see Control Messages
                                                                                                                                                                                                                            	// (https://en.wikipedia.org/wiki/Internet_Control_Message_Protocol#Control_messages)
                                                                                                                                                                                                                            	// on Wikipedia.
                                                                                                                                                                                                                            	ToPort int32
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              Describes open ports on an instance, the IP addresses allowed to connect to the instance through the ports, and the protocol.

                                                                                                                                                                                                                              type InstanceSnapshot

                                                                                                                                                                                                                              type InstanceSnapshot struct {
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the snapshot (e.g.,
                                                                                                                                                                                                                              	// arn:aws:lightsail:us-east-2:123456789101:InstanceSnapshot/d23b5706-3322-4d83-81e5-12345EXAMPLE).
                                                                                                                                                                                                                              	Arn *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The timestamp when the snapshot was created (e.g., 1479907467.024).
                                                                                                                                                                                                                              	CreatedAt *time.Time
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// An array of disk objects containing information about all block storage disks.
                                                                                                                                                                                                                              	FromAttachedDisks []Disk
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The blueprint ID from which you created the snapshot (e.g., os_debian_8_3). A
                                                                                                                                                                                                                              	// blueprint is a virtual private server (or instance) image used to create
                                                                                                                                                                                                                              	// instances quickly.
                                                                                                                                                                                                                              	FromBlueprintId *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The bundle ID from which you created the snapshot (e.g., micro_1_0).
                                                                                                                                                                                                                              	FromBundleId *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the instance from which the snapshot was
                                                                                                                                                                                                                              	// created (e.g.,
                                                                                                                                                                                                                              	// arn:aws:lightsail:us-east-2:123456789101:Instance/64b8404c-ccb1-430b-8daf-12345EXAMPLE).
                                                                                                                                                                                                                              	FromInstanceArn *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The instance from which the snapshot was created.
                                                                                                                                                                                                                              	FromInstanceName *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// A Boolean value indicating whether the snapshot was created from an automatic
                                                                                                                                                                                                                              	// snapshot.
                                                                                                                                                                                                                              	IsFromAutoSnapshot *bool
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The region name and Availability Zone where you created the snapshot.
                                                                                                                                                                                                                              	Location *ResourceLocation
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The name of the snapshot.
                                                                                                                                                                                                                              	Name *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The progress of the snapshot.
                                                                                                                                                                                                                              	Progress *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The type of resource (usually InstanceSnapshot).
                                                                                                                                                                                                                              	ResourceType ResourceType
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The size in GB of the SSD.
                                                                                                                                                                                                                              	SizeInGb *int32
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The state the snapshot is in.
                                                                                                                                                                                                                              	State InstanceSnapshotState
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The support code. Include this code in your email to support when you have
                                                                                                                                                                                                                              	// questions about an instance or another resource in Lightsail. This code enables
                                                                                                                                                                                                                              	// our support team to look up your Lightsail information more easily.
                                                                                                                                                                                                                              	SupportCode *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The tag keys and optional values for the resource. For more information about
                                                                                                                                                                                                                              	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                                                                                                                                                              	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                                                                                                                                                              	Tags []Tag
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                Describes an instance snapshot.

                                                                                                                                                                                                                                type InstanceSnapshotInfo

                                                                                                                                                                                                                                type InstanceSnapshotInfo struct {
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// The blueprint ID from which the source instance (e.g., os_debian_8_3).
                                                                                                                                                                                                                                	FromBlueprintId *string
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// The bundle ID from which the source instance was created (e.g., micro_1_0).
                                                                                                                                                                                                                                	FromBundleId *string
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// A list of objects describing the disks that were attached to the source
                                                                                                                                                                                                                                	// instance.
                                                                                                                                                                                                                                	FromDiskInfo []DiskInfo
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  Describes an instance snapshot.

                                                                                                                                                                                                                                  type InstanceSnapshotState

                                                                                                                                                                                                                                  type InstanceSnapshotState string
                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                  	InstanceSnapshotStatePending   InstanceSnapshotState = "pending"
                                                                                                                                                                                                                                  	InstanceSnapshotStateError     InstanceSnapshotState = "error"
                                                                                                                                                                                                                                  	InstanceSnapshotStateAvailable InstanceSnapshotState = "available"
                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                    Enum values for InstanceSnapshotState

                                                                                                                                                                                                                                    func (InstanceSnapshotState) Values

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

                                                                                                                                                                                                                                      type InstanceState

                                                                                                                                                                                                                                      type InstanceState struct {
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The status code for the instance.
                                                                                                                                                                                                                                      	Code *int32
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The state of the instance (e.g., running or pending).
                                                                                                                                                                                                                                      	Name *string
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        Describes the virtual private server (or instance) status.

                                                                                                                                                                                                                                        type InvalidInputException

                                                                                                                                                                                                                                        type InvalidInputException struct {
                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	Code *string
                                                                                                                                                                                                                                        	Docs *string
                                                                                                                                                                                                                                        	Tip  *string
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          Lightsail throws this exception when user input does not conform to the validation rules of an input field. Domain-related APIs are only available in the N. Virginia (us-east-1) Region. Please set your AWS Region configuration to us-east-1 to create, view, or edit these resources.

                                                                                                                                                                                                                                          func (*InvalidInputException) Error

                                                                                                                                                                                                                                          func (e *InvalidInputException) Error() string

                                                                                                                                                                                                                                          func (*InvalidInputException) ErrorCode

                                                                                                                                                                                                                                          func (e *InvalidInputException) ErrorCode() string

                                                                                                                                                                                                                                          func (*InvalidInputException) ErrorFault

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

                                                                                                                                                                                                                                          func (*InvalidInputException) ErrorMessage

                                                                                                                                                                                                                                          func (e *InvalidInputException) ErrorMessage() string

                                                                                                                                                                                                                                          type KeyPair

                                                                                                                                                                                                                                          type KeyPair struct {
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the key pair (e.g.,
                                                                                                                                                                                                                                          	// arn:aws:lightsail:us-east-2:123456789101:KeyPair/05859e3d-331d-48ba-9034-12345EXAMPLE).
                                                                                                                                                                                                                                          	Arn *string
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The timestamp when the key pair was created (e.g., 1479816991.349).
                                                                                                                                                                                                                                          	CreatedAt *time.Time
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The RSA fingerprint of the key pair.
                                                                                                                                                                                                                                          	Fingerprint *string
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The region name and Availability Zone where the key pair was created.
                                                                                                                                                                                                                                          	Location *ResourceLocation
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The friendly name of the SSH key pair.
                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The resource type (usually KeyPair).
                                                                                                                                                                                                                                          	ResourceType ResourceType
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The support code. Include this code in your email to support when you have
                                                                                                                                                                                                                                          	// questions about an instance or another resource in Lightsail. This code enables
                                                                                                                                                                                                                                          	// our support team to look up your Lightsail information more easily.
                                                                                                                                                                                                                                          	SupportCode *string
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The tag keys and optional values for the resource. For more information about
                                                                                                                                                                                                                                          	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                                                                                                                                                                          	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                                                                                                                                                                          	Tags []Tag
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            Describes the SSH key pair.

                                                                                                                                                                                                                                            type LightsailDistribution

                                                                                                                                                                                                                                            type LightsailDistribution struct {
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// Indicates whether the bundle that is currently applied to your distribution,
                                                                                                                                                                                                                                            	// specified using the distributionName parameter, can be changed to another
                                                                                                                                                                                                                                            	// bundle. Use the UpdateDistributionBundle action to change your distribution's
                                                                                                                                                                                                                                            	// bundle.
                                                                                                                                                                                                                                            	AbleToUpdateBundle *bool
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The alternate domain names of the distribution.
                                                                                                                                                                                                                                            	AlternativeDomainNames []string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) of the distribution.
                                                                                                                                                                                                                                            	Arn *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The ID of the bundle currently applied to the distribution.
                                                                                                                                                                                                                                            	BundleId *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// An object that describes the cache behavior settings of the distribution.
                                                                                                                                                                                                                                            	CacheBehaviorSettings *CacheSettings
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// An array of objects that describe the per-path cache behavior of the
                                                                                                                                                                                                                                            	// distribution.
                                                                                                                                                                                                                                            	CacheBehaviors []CacheBehaviorPerPath
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The name of the SSL/TLS certificate attached to the distribution, if any.
                                                                                                                                                                                                                                            	CertificateName *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The timestamp when the distribution was created.
                                                                                                                                                                                                                                            	CreatedAt *time.Time
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// An object that describes the default cache behavior of the distribution.
                                                                                                                                                                                                                                            	DefaultCacheBehavior *CacheBehavior
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The domain name of the distribution.
                                                                                                                                                                                                                                            	DomainName *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// Indicates whether the distribution is enabled.
                                                                                                                                                                                                                                            	IsEnabled *bool
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// An object that describes the location of the distribution, such as the AWS
                                                                                                                                                                                                                                            	// Region and Availability Zone. Lightsail distributions are global resources that
                                                                                                                                                                                                                                            	// can reference an origin in any AWS Region, and distribute its content globally.
                                                                                                                                                                                                                                            	// However, all distributions are located in the us-east-1 Region.
                                                                                                                                                                                                                                            	Location *ResourceLocation
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The name of the distribution.
                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// An object that describes the origin resource of the distribution, such as a
                                                                                                                                                                                                                                            	// Lightsail instance or load balancer. The distribution pulls, caches, and serves
                                                                                                                                                                                                                                            	// content from the origin.
                                                                                                                                                                                                                                            	Origin *Origin
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The public DNS of the origin.
                                                                                                                                                                                                                                            	OriginPublicDNS *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The Lightsail resource type (e.g., Distribution).
                                                                                                                                                                                                                                            	ResourceType ResourceType
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The status of the distribution.
                                                                                                                                                                                                                                            	Status *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The support code. Include this code in your email to support when you have
                                                                                                                                                                                                                                            	// questions about your Lightsail distribution. This code enables our support team
                                                                                                                                                                                                                                            	// to look up your Lightsail information more easily.
                                                                                                                                                                                                                                            	SupportCode *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The tag keys and optional values for the resource. For more information about
                                                                                                                                                                                                                                            	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                                                                                                                                                                            	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                                                                                                                                                                            	Tags []Tag
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              Describes an Amazon Lightsail content delivery network (CDN) distribution.

                                                                                                                                                                                                                                              type LoadBalancer

                                                                                                                                                                                                                                              type LoadBalancer struct {
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the load balancer.
                                                                                                                                                                                                                                              	Arn *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// A string to string map of the configuration options for your load balancer.
                                                                                                                                                                                                                                              	// Valid values are listed below.
                                                                                                                                                                                                                                              	ConfigurationOptions map[string]string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The date when your load balancer was created.
                                                                                                                                                                                                                                              	CreatedAt *time.Time
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The DNS name of your Lightsail load balancer.
                                                                                                                                                                                                                                              	DnsName *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The path you specified to perform your health checks. If no path is specified,
                                                                                                                                                                                                                                              	// the load balancer tries to make a request to the default (root) page.
                                                                                                                                                                                                                                              	HealthCheckPath *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// An array of InstanceHealthSummary objects describing the health of the load
                                                                                                                                                                                                                                              	// balancer.
                                                                                                                                                                                                                                              	InstanceHealthSummary []InstanceHealthSummary
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The port where the load balancer will direct traffic to your Lightsail
                                                                                                                                                                                                                                              	// instances. For HTTP traffic, it's port 80. For HTTPS traffic, it's port 443.
                                                                                                                                                                                                                                              	InstancePort *int32
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The AWS Region where your load balancer was created (e.g., us-east-2a).
                                                                                                                                                                                                                                              	// Lightsail automatically creates your load balancer across Availability Zones.
                                                                                                                                                                                                                                              	Location *ResourceLocation
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The name of the load balancer (e.g., my-load-balancer).
                                                                                                                                                                                                                                              	Name *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The protocol you have enabled for your load balancer. Valid values are below.
                                                                                                                                                                                                                                              	// You can't just have HTTP_HTTPS, but you can have just HTTP.
                                                                                                                                                                                                                                              	Protocol LoadBalancerProtocol
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// An array of public port settings for your load balancer. For HTTP, use port 80.
                                                                                                                                                                                                                                              	// For HTTPS, use port 443.
                                                                                                                                                                                                                                              	PublicPorts []int32
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The resource type (e.g., LoadBalancer.
                                                                                                                                                                                                                                              	ResourceType ResourceType
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The status of your load balancer. Valid values are below.
                                                                                                                                                                                                                                              	State LoadBalancerState
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The support code. Include this code in your email to support when you have
                                                                                                                                                                                                                                              	// questions about your Lightsail load balancer. This code enables our support team
                                                                                                                                                                                                                                              	// to look up your Lightsail information more easily.
                                                                                                                                                                                                                                              	SupportCode *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The tag keys and optional values for the resource. For more information about
                                                                                                                                                                                                                                              	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                                                                                                                                                                              	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                                                                                                                                                                              	Tags []Tag
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// An array of LoadBalancerTlsCertificateSummary objects that provide additional
                                                                                                                                                                                                                                              	// information about the SSL/TLS certificates. For example, if true, the
                                                                                                                                                                                                                                              	// certificate is attached to the load balancer.
                                                                                                                                                                                                                                              	TlsCertificateSummaries []LoadBalancerTlsCertificateSummary
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                Describes the Lightsail load balancer.

                                                                                                                                                                                                                                                type LoadBalancerAttributeName

                                                                                                                                                                                                                                                type LoadBalancerAttributeName string
                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                	LoadBalancerAttributeNameHealthCheckPath                          LoadBalancerAttributeName = "HealthCheckPath"
                                                                                                                                                                                                                                                	LoadBalancerAttributeNameSessionStickinessEnabled                 LoadBalancerAttributeName = "SessionStickinessEnabled"
                                                                                                                                                                                                                                                	LoadBalancerAttributeNameSessionStickinessLbCookieDurationSeconds LoadBalancerAttributeName = "SessionStickiness_LB_CookieDurationSeconds"
                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                  Enum values for LoadBalancerAttributeName

                                                                                                                                                                                                                                                  func (LoadBalancerAttributeName) Values

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

                                                                                                                                                                                                                                                    type LoadBalancerMetricName

                                                                                                                                                                                                                                                    type LoadBalancerMetricName string
                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameClientTLSNegotiationErrorCount LoadBalancerMetricName = "ClientTLSNegotiationErrorCount"
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameHealthyHostCount               LoadBalancerMetricName = "HealthyHostCount"
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameUnhealthyHostCount             LoadBalancerMetricName = "UnhealthyHostCount"
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameHTTPCodeLb4xxCount             LoadBalancerMetricName = "HTTPCode_LB_4XX_Count"
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameHTTPCodeLb5xxCount             LoadBalancerMetricName = "HTTPCode_LB_5XX_Count"
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameHTTPCodeInstance2xxCount       LoadBalancerMetricName = "HTTPCode_Instance_2XX_Count"
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameHTTPCodeInstance3xxCount       LoadBalancerMetricName = "HTTPCode_Instance_3XX_Count"
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameHTTPCodeInstance4xxCount       LoadBalancerMetricName = "HTTPCode_Instance_4XX_Count"
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameHTTPCodeInstance5xxCount       LoadBalancerMetricName = "HTTPCode_Instance_5XX_Count"
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameInstanceResponseTime           LoadBalancerMetricName = "InstanceResponseTime"
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameRejectedConnectionCount        LoadBalancerMetricName = "RejectedConnectionCount"
                                                                                                                                                                                                                                                    	LoadBalancerMetricNameRequestCount                   LoadBalancerMetricName = "RequestCount"
                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                      Enum values for LoadBalancerMetricName

                                                                                                                                                                                                                                                      func (LoadBalancerMetricName) Values

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

                                                                                                                                                                                                                                                        type LoadBalancerProtocol

                                                                                                                                                                                                                                                        type LoadBalancerProtocol string
                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                        	LoadBalancerProtocolHttpHttps LoadBalancerProtocol = "HTTP_HTTPS"
                                                                                                                                                                                                                                                        	LoadBalancerProtocolHttp      LoadBalancerProtocol = "HTTP"
                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                          Enum values for LoadBalancerProtocol

                                                                                                                                                                                                                                                          func (LoadBalancerProtocol) Values

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

                                                                                                                                                                                                                                                            type LoadBalancerState

                                                                                                                                                                                                                                                            type LoadBalancerState string
                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                            	LoadBalancerStateActive         LoadBalancerState = "active"
                                                                                                                                                                                                                                                            	LoadBalancerStateProvisioning   LoadBalancerState = "provisioning"
                                                                                                                                                                                                                                                            	LoadBalancerStateActiveImpaired LoadBalancerState = "active_impaired"
                                                                                                                                                                                                                                                            	LoadBalancerStateFailed         LoadBalancerState = "failed"
                                                                                                                                                                                                                                                            	LoadBalancerStateUnknown        LoadBalancerState = "unknown"
                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                              Enum values for LoadBalancerState

                                                                                                                                                                                                                                                              func (LoadBalancerState) Values

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

                                                                                                                                                                                                                                                                type LoadBalancerTlsCertificate

                                                                                                                                                                                                                                                                type LoadBalancerTlsCertificate struct {
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The Amazon Resource Name (ARN) of the SSL/TLS certificate.
                                                                                                                                                                                                                                                                	Arn *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The time when you created your SSL/TLS certificate.
                                                                                                                                                                                                                                                                	CreatedAt *time.Time
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The domain name for your SSL/TLS certificate.
                                                                                                                                                                                                                                                                	DomainName *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// An array of LoadBalancerTlsCertificateDomainValidationRecord objects describing
                                                                                                                                                                                                                                                                	// the records.
                                                                                                                                                                                                                                                                	DomainValidationRecords []LoadBalancerTlsCertificateDomainValidationRecord
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The validation failure reason, if any, of the certificate. The following failure
                                                                                                                                                                                                                                                                	// reasons are possible:
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * NO_AVAILABLE_CONTACTS - This failure applies to email
                                                                                                                                                                                                                                                                	// validation, which is not available for Lightsail certificates.
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// *
                                                                                                                                                                                                                                                                	// ADDITIONAL_VERIFICATION_REQUIRED - Lightsail requires additional information to
                                                                                                                                                                                                                                                                	// process this certificate request. This can happen as a fraud-protection measure,
                                                                                                                                                                                                                                                                	// such as when the domain ranks within the Alexa top 1000 websites. To provide the
                                                                                                                                                                                                                                                                	// required information, use the AWS Support Center
                                                                                                                                                                                                                                                                	// (https://console.aws.amazon.com/support/home) to contact AWS Support. You cannot
                                                                                                                                                                                                                                                                	// request a certificate for Amazon-owned domain names such as those ending in
                                                                                                                                                                                                                                                                	// amazonaws.com, cloudfront.net, or elasticbeanstalk.com.
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * DOMAIN_NOT_ALLOWED -
                                                                                                                                                                                                                                                                	// One or more of the domain names in the certificate request was reported as an
                                                                                                                                                                                                                                                                	// unsafe domain by VirusTotal (https://www.virustotal.com/gui/home/url). To
                                                                                                                                                                                                                                                                	// correct the problem, search for your domain name on the VirusTotal
                                                                                                                                                                                                                                                                	// (https://www.virustotal.com/gui/home/url) website. If your domain is reported as
                                                                                                                                                                                                                                                                	// suspicious, see Google Help for Hacked Websites
                                                                                                                                                                                                                                                                	// (https://www.google.com/webmasters/hacked/?hl=en) to learn what you can do. If
                                                                                                                                                                                                                                                                	// you believe that the result is a false positive, notify the organization that is
                                                                                                                                                                                                                                                                	// reporting the domain. VirusTotal is an aggregate of several antivirus and URL
                                                                                                                                                                                                                                                                	// scanners and cannot remove your domain from a block list itself. After you
                                                                                                                                                                                                                                                                	// correct the problem and the VirusTotal registry has been updated, request a new
                                                                                                                                                                                                                                                                	// certificate. If you see this error and your domain is not included in the
                                                                                                                                                                                                                                                                	// VirusTotal list, visit the AWS Support Center
                                                                                                                                                                                                                                                                	// (https://console.aws.amazon.com/support/home) and create a case.
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// *
                                                                                                                                                                                                                                                                	// INVALID_PUBLIC_DOMAIN - One or more of the domain names in the certificate
                                                                                                                                                                                                                                                                	// request is not valid. Typically, this is because a domain name in the request is
                                                                                                                                                                                                                                                                	// not a valid top-level domain. Try to request a certificate again, correcting any
                                                                                                                                                                                                                                                                	// spelling errors or typos that were in the failed request, and ensure that all
                                                                                                                                                                                                                                                                	// domain names in the request are for valid top-level domains. For example, you
                                                                                                                                                                                                                                                                	// cannot request a certificate for example.invalidpublicdomain because
                                                                                                                                                                                                                                                                	// invalidpublicdomain is not a valid top-level domain.
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * OTHER - Typically, this
                                                                                                                                                                                                                                                                	// failure occurs when there is a typographical error in one or more of the domain
                                                                                                                                                                                                                                                                	// names in the certificate request. Try to request a certificate again, correcting
                                                                                                                                                                                                                                                                	// any spelling errors or typos that were in the failed request.
                                                                                                                                                                                                                                                                	FailureReason LoadBalancerTlsCertificateFailureReason
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// When true, the SSL/TLS certificate is attached to the Lightsail load balancer.
                                                                                                                                                                                                                                                                	IsAttached *bool
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The time when the SSL/TLS certificate was issued.
                                                                                                                                                                                                                                                                	IssuedAt *time.Time
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The issuer of the certificate.
                                                                                                                                                                                                                                                                	Issuer *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The algorithm used to generate the key pair (the public and private key).
                                                                                                                                                                                                                                                                	KeyAlgorithm *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The load balancer name where your SSL/TLS certificate is attached.
                                                                                                                                                                                                                                                                	LoadBalancerName *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The AWS Region and Availability Zone where you created your certificate.
                                                                                                                                                                                                                                                                	Location *ResourceLocation
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The name of the SSL/TLS certificate (e.g., my-certificate).
                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The timestamp when the SSL/TLS certificate expires.
                                                                                                                                                                                                                                                                	NotAfter *time.Time
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The timestamp when the SSL/TLS certificate is first valid.
                                                                                                                                                                                                                                                                	NotBefore *time.Time
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// An object that describes the status of the certificate renewal managed by
                                                                                                                                                                                                                                                                	// Lightsail.
                                                                                                                                                                                                                                                                	RenewalSummary *LoadBalancerTlsCertificateRenewalSummary
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The resource type (e.g., LoadBalancerTlsCertificate).
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * Instance - A Lightsail
                                                                                                                                                                                                                                                                	// instance (a virtual private server)
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * StaticIp - A static IP address
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * KeyPair
                                                                                                                                                                                                                                                                	// - The key pair used to connect to a Lightsail instance
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * InstanceSnapshot - A
                                                                                                                                                                                                                                                                	// Lightsail instance snapshot
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * Domain - A DNS zone
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * PeeredVpc - A peered
                                                                                                                                                                                                                                                                	// VPC
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * LoadBalancer - A Lightsail load balancer
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * LoadBalancerTlsCertificate -
                                                                                                                                                                                                                                                                	// An SSL/TLS certificate associated with a Lightsail load balancer
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * Disk - A
                                                                                                                                                                                                                                                                	// Lightsail block storage disk
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// * DiskSnapshot - A block storage disk snapshot
                                                                                                                                                                                                                                                                	ResourceType ResourceType
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The reason the certificate was revoked. This value is present only when the
                                                                                                                                                                                                                                                                	// certificate status is REVOKED.
                                                                                                                                                                                                                                                                	RevocationReason LoadBalancerTlsCertificateRevocationReason
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The timestamp when the certificate was revoked. This value is present only when
                                                                                                                                                                                                                                                                	// the certificate status is REVOKED.
                                                                                                                                                                                                                                                                	RevokedAt *time.Time
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The serial number of the certificate.
                                                                                                                                                                                                                                                                	Serial *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The algorithm that was used to sign the certificate.
                                                                                                                                                                                                                                                                	SignatureAlgorithm *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The validation status of the SSL/TLS certificate. Valid values are below.
                                                                                                                                                                                                                                                                	Status LoadBalancerTlsCertificateStatus
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The name of the entity that is associated with the public key contained in the
                                                                                                                                                                                                                                                                	// certificate.
                                                                                                                                                                                                                                                                	Subject *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// An array of strings that specify the alternate domains (e.g., example2.com) and
                                                                                                                                                                                                                                                                	// subdomains (e.g., blog.example.com) for the certificate.
                                                                                                                                                                                                                                                                	SubjectAlternativeNames []string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The support code. Include this code in your email to support when you have
                                                                                                                                                                                                                                                                	// questions about your Lightsail load balancer or SSL/TLS certificate. This code
                                                                                                                                                                                                                                                                	// enables our support team to look up your Lightsail information more easily.
                                                                                                                                                                                                                                                                	SupportCode *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The tag keys and optional values for the resource. For more information about
                                                                                                                                                                                                                                                                	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                                                                                                                                                                                                	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                                                                                                                                                                                                	Tags []Tag
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  Describes a load balancer SSL/TLS certificate. TLS is just an updated, more secure version of Secure Socket Layer (SSL).

                                                                                                                                                                                                                                                                  type LoadBalancerTlsCertificateDomainStatus

                                                                                                                                                                                                                                                                  type LoadBalancerTlsCertificateDomainStatus string
                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                  	LoadBalancerTlsCertificateDomainStatusPendingValidation LoadBalancerTlsCertificateDomainStatus = "PENDING_VALIDATION"
                                                                                                                                                                                                                                                                  	LoadBalancerTlsCertificateDomainStatusFailed            LoadBalancerTlsCertificateDomainStatus = "FAILED"
                                                                                                                                                                                                                                                                  	LoadBalancerTlsCertificateDomainStatusSuccess           LoadBalancerTlsCertificateDomainStatus = "SUCCESS"
                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                    Enum values for LoadBalancerTlsCertificateDomainStatus

                                                                                                                                                                                                                                                                    func (LoadBalancerTlsCertificateDomainStatus) Values

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

                                                                                                                                                                                                                                                                      type LoadBalancerTlsCertificateDomainValidationOption

                                                                                                                                                                                                                                                                      type LoadBalancerTlsCertificateDomainValidationOption struct {
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// The fully qualified domain name in the certificate request.
                                                                                                                                                                                                                                                                      	DomainName *string
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// The status of the domain validation. Valid values are listed below.
                                                                                                                                                                                                                                                                      	ValidationStatus LoadBalancerTlsCertificateDomainStatus
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        Contains information about the domain names on an SSL/TLS certificate that you will use to validate domain ownership.

                                                                                                                                                                                                                                                                        type LoadBalancerTlsCertificateDomainValidationRecord

                                                                                                                                                                                                                                                                        type LoadBalancerTlsCertificateDomainValidationRecord struct {
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// The domain name against which your SSL/TLS certificate was validated.
                                                                                                                                                                                                                                                                        	DomainName *string
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// A fully qualified domain name in the certificate. For example, example.com.
                                                                                                                                                                                                                                                                        	Name *string
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// The type of validation record. For example, CNAME for domain validation.
                                                                                                                                                                                                                                                                        	Type *string
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// The validation status. Valid values are listed below.
                                                                                                                                                                                                                                                                        	ValidationStatus LoadBalancerTlsCertificateDomainStatus
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// The value for that type.
                                                                                                                                                                                                                                                                        	Value *string
                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                          Describes the validation record of each domain name in the SSL/TLS certificate.

                                                                                                                                                                                                                                                                          type LoadBalancerTlsCertificateFailureReason

                                                                                                                                                                                                                                                                          type LoadBalancerTlsCertificateFailureReason string
                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                          	LoadBalancerTlsCertificateFailureReasonNoAvailableContacts            LoadBalancerTlsCertificateFailureReason = "NO_AVAILABLE_CONTACTS"
                                                                                                                                                                                                                                                                          	LoadBalancerTlsCertificateFailureReasonAdditionalVerificationRequired LoadBalancerTlsCertificateFailureReason = "ADDITIONAL_VERIFICATION_REQUIRED"
                                                                                                                                                                                                                                                                          	LoadBalancerTlsCertificateFailureReasonDomainNotAllowed               LoadBalancerTlsCertificateFailureReason = "DOMAIN_NOT_ALLOWED"
                                                                                                                                                                                                                                                                          	LoadBalancerTlsCertificateFailureReasonInvalidPublicDomain            LoadBalancerTlsCertificateFailureReason = "INVALID_PUBLIC_DOMAIN"
                                                                                                                                                                                                                                                                          	LoadBalancerTlsCertificateFailureReasonOther                          LoadBalancerTlsCertificateFailureReason = "OTHER"
                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                            Enum values for LoadBalancerTlsCertificateFailureReason

                                                                                                                                                                                                                                                                            func (LoadBalancerTlsCertificateFailureReason) Values

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

                                                                                                                                                                                                                                                                              type LoadBalancerTlsCertificateRenewalStatus

                                                                                                                                                                                                                                                                              type LoadBalancerTlsCertificateRenewalStatus string
                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                              	LoadBalancerTlsCertificateRenewalStatusPendingAutoRenewal LoadBalancerTlsCertificateRenewalStatus = "PENDING_AUTO_RENEWAL"
                                                                                                                                                                                                                                                                              	LoadBalancerTlsCertificateRenewalStatusPendingValidation  LoadBalancerTlsCertificateRenewalStatus = "PENDING_VALIDATION"
                                                                                                                                                                                                                                                                              	LoadBalancerTlsCertificateRenewalStatusSuccess            LoadBalancerTlsCertificateRenewalStatus = "SUCCESS"
                                                                                                                                                                                                                                                                              	LoadBalancerTlsCertificateRenewalStatusFailed             LoadBalancerTlsCertificateRenewalStatus = "FAILED"
                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                Enum values for LoadBalancerTlsCertificateRenewalStatus

                                                                                                                                                                                                                                                                                func (LoadBalancerTlsCertificateRenewalStatus) Values

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

                                                                                                                                                                                                                                                                                  type LoadBalancerTlsCertificateRenewalSummary

                                                                                                                                                                                                                                                                                  type LoadBalancerTlsCertificateRenewalSummary struct {
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// Contains information about the validation of each domain name in the
                                                                                                                                                                                                                                                                                  	// certificate, as it pertains to Lightsail's managed renewal. This is different
                                                                                                                                                                                                                                                                                  	// from the initial validation that occurs as a result of the RequestCertificate
                                                                                                                                                                                                                                                                                  	// request.
                                                                                                                                                                                                                                                                                  	DomainValidationOptions []LoadBalancerTlsCertificateDomainValidationOption
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The renewal status of the certificate. The following renewal status are
                                                                                                                                                                                                                                                                                  	// possible:
                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                  	// * PendingAutoRenewal - Lightsail is attempting to automatically
                                                                                                                                                                                                                                                                                  	// validate the domain names of the certificate. No further action is required.
                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                                  	// PendingValidation - Lightsail couldn't automatically validate one or more domain
                                                                                                                                                                                                                                                                                  	// names of the certificate. You must take action to validate these domain names or
                                                                                                                                                                                                                                                                                  	// the certificate won't be renewed. Check to make sure your certificate's domain
                                                                                                                                                                                                                                                                                  	// validation records exist in your domain's DNS, and that your certificate remains
                                                                                                                                                                                                                                                                                  	// in use.
                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                  	// * Success - All domain names in the certificate are validated, and
                                                                                                                                                                                                                                                                                  	// Lightsail renewed the certificate. No further action is required.
                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                  	// * Failed -
                                                                                                                                                                                                                                                                                  	// One or more domain names were not validated before the certificate expired, and
                                                                                                                                                                                                                                                                                  	// Lightsail did not renew the certificate. You can request a new certificate using
                                                                                                                                                                                                                                                                                  	// the CreateCertificate action.
                                                                                                                                                                                                                                                                                  	RenewalStatus LoadBalancerTlsCertificateRenewalStatus
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    Contains information about the status of Lightsail's managed renewal for the certificate. The renewal status of the certificate. The following renewal status are possible:

                                                                                                                                                                                                                                                                                    * PendingAutoRenewal - Lightsail is attempting to automatically validate the domain names in the certificate. No further action is required.

                                                                                                                                                                                                                                                                                    * PendingValidation - Lightsail couldn't automatically validate one or more domain names in the certificate. You must take action to validate these domain names or the certificate won't be renewed. If you used DNS validation, check to make sure your certificate's domain validation records exist in your domain's DNS, and that your certificate remains in use.

                                                                                                                                                                                                                                                                                    * Success - All domain names in the certificate are validated, and Lightsail renewed the certificate. No further action is required.

                                                                                                                                                                                                                                                                                    * Failed - One or more domain names were not validated before the certificate expired, and Lightsail did not renew the certificate. You can request a new certificate using the CreateCertificate action.

                                                                                                                                                                                                                                                                                    type LoadBalancerTlsCertificateRevocationReason

                                                                                                                                                                                                                                                                                    type LoadBalancerTlsCertificateRevocationReason string
                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                    	LoadBalancerTlsCertificateRevocationReasonUnspecified          LoadBalancerTlsCertificateRevocationReason = "UNSPECIFIED"
                                                                                                                                                                                                                                                                                    	LoadBalancerTlsCertificateRevocationReasonKeyCompromise        LoadBalancerTlsCertificateRevocationReason = "KEY_COMPROMISE"
                                                                                                                                                                                                                                                                                    	LoadBalancerTlsCertificateRevocationReasonCaCompromise         LoadBalancerTlsCertificateRevocationReason = "CA_COMPROMISE"
                                                                                                                                                                                                                                                                                    	LoadBalancerTlsCertificateRevocationReasonAffiliationChanged   LoadBalancerTlsCertificateRevocationReason = "AFFILIATION_CHANGED"
                                                                                                                                                                                                                                                                                    	LoadBalancerTlsCertificateRevocationReasonSuperceded           LoadBalancerTlsCertificateRevocationReason = "SUPERCEDED"
                                                                                                                                                                                                                                                                                    	LoadBalancerTlsCertificateRevocationReasonCessationOfOperation LoadBalancerTlsCertificateRevocationReason = "CESSATION_OF_OPERATION"
                                                                                                                                                                                                                                                                                    	LoadBalancerTlsCertificateRevocationReasonCertificateHold      LoadBalancerTlsCertificateRevocationReason = "CERTIFICATE_HOLD"
                                                                                                                                                                                                                                                                                    	LoadBalancerTlsCertificateRevocationReasonRemoveFromCrl        LoadBalancerTlsCertificateRevocationReason = "REMOVE_FROM_CRL"
                                                                                                                                                                                                                                                                                    	LoadBalancerTlsCertificateRevocationReasonPrivilegeWithdrawn   LoadBalancerTlsCertificateRevocationReason = "PRIVILEGE_WITHDRAWN"
                                                                                                                                                                                                                                                                                    	LoadBalancerTlsCertificateRevocationReasonAACompromise         LoadBalancerTlsCertificateRevocationReason = "A_A_COMPROMISE"
                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                      Enum values for LoadBalancerTlsCertificateRevocationReason

                                                                                                                                                                                                                                                                                      func (LoadBalancerTlsCertificateRevocationReason) Values

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

                                                                                                                                                                                                                                                                                        type LoadBalancerTlsCertificateStatus

                                                                                                                                                                                                                                                                                        type LoadBalancerTlsCertificateStatus string
                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                        	LoadBalancerTlsCertificateStatusPendingValidation  LoadBalancerTlsCertificateStatus = "PENDING_VALIDATION"
                                                                                                                                                                                                                                                                                        	LoadBalancerTlsCertificateStatusIssued             LoadBalancerTlsCertificateStatus = "ISSUED"
                                                                                                                                                                                                                                                                                        	LoadBalancerTlsCertificateStatusInactive           LoadBalancerTlsCertificateStatus = "INACTIVE"
                                                                                                                                                                                                                                                                                        	LoadBalancerTlsCertificateStatusExpired            LoadBalancerTlsCertificateStatus = "EXPIRED"
                                                                                                                                                                                                                                                                                        	LoadBalancerTlsCertificateStatusValidationTimedOut LoadBalancerTlsCertificateStatus = "VALIDATION_TIMED_OUT"
                                                                                                                                                                                                                                                                                        	LoadBalancerTlsCertificateStatusRevoked            LoadBalancerTlsCertificateStatus = "REVOKED"
                                                                                                                                                                                                                                                                                        	LoadBalancerTlsCertificateStatusFailed             LoadBalancerTlsCertificateStatus = "FAILED"
                                                                                                                                                                                                                                                                                        	LoadBalancerTlsCertificateStatusUnknown            LoadBalancerTlsCertificateStatus = "UNKNOWN"
                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                          Enum values for LoadBalancerTlsCertificateStatus

                                                                                                                                                                                                                                                                                          func (LoadBalancerTlsCertificateStatus) Values

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

                                                                                                                                                                                                                                                                                            type LoadBalancerTlsCertificateSummary

                                                                                                                                                                                                                                                                                            type LoadBalancerTlsCertificateSummary struct {
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// When true, the SSL/TLS certificate is attached to the Lightsail load balancer.
                                                                                                                                                                                                                                                                                            	IsAttached *bool
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The name of the SSL/TLS certificate.
                                                                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              Provides a summary of SSL/TLS certificate metadata.

                                                                                                                                                                                                                                                                                              type LogEvent

                                                                                                                                                                                                                                                                                              type LogEvent struct {
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// The timestamp when the database log event was created.
                                                                                                                                                                                                                                                                                              	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// The message of the database log event.
                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                Describes a database log event.

                                                                                                                                                                                                                                                                                                type MetricDatapoint

                                                                                                                                                                                                                                                                                                type MetricDatapoint struct {
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// The average.
                                                                                                                                                                                                                                                                                                	Average *float64
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// The maximum.
                                                                                                                                                                                                                                                                                                	Maximum *float64
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// The minimum.
                                                                                                                                                                                                                                                                                                	Minimum *float64
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// The sample count.
                                                                                                                                                                                                                                                                                                	SampleCount *float64
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// The sum.
                                                                                                                                                                                                                                                                                                	Sum *float64
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// The timestamp (e.g., 1479816991.349).
                                                                                                                                                                                                                                                                                                	Timestamp *time.Time
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// The unit.
                                                                                                                                                                                                                                                                                                	Unit MetricUnit
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  Describes the metric data point.

                                                                                                                                                                                                                                                                                                  type MetricName

                                                                                                                                                                                                                                                                                                  type MetricName string
                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                  	MetricNameCPUUtilization                 MetricName = "CPUUtilization"
                                                                                                                                                                                                                                                                                                  	MetricNameNetworkIn                      MetricName = "NetworkIn"
                                                                                                                                                                                                                                                                                                  	MetricNameNetworkOut                     MetricName = "NetworkOut"
                                                                                                                                                                                                                                                                                                  	MetricNameStatusCheckFailed              MetricName = "StatusCheckFailed"
                                                                                                                                                                                                                                                                                                  	MetricNameStatusCheckFailedInstance      MetricName = "StatusCheckFailed_Instance"
                                                                                                                                                                                                                                                                                                  	MetricNameStatusCheckFailedSystem        MetricName = "StatusCheckFailed_System"
                                                                                                                                                                                                                                                                                                  	MetricNameClientTLSNegotiationErrorCount MetricName = "ClientTLSNegotiationErrorCount"
                                                                                                                                                                                                                                                                                                  	MetricNameHealthyHostCount               MetricName = "HealthyHostCount"
                                                                                                                                                                                                                                                                                                  	MetricNameUnhealthyHostCount             MetricName = "UnhealthyHostCount"
                                                                                                                                                                                                                                                                                                  	MetricNameHTTPCodeLb4xxCount             MetricName = "HTTPCode_LB_4XX_Count"
                                                                                                                                                                                                                                                                                                  	MetricNameHTTPCodeLb5xxCount             MetricName = "HTTPCode_LB_5XX_Count"
                                                                                                                                                                                                                                                                                                  	MetricNameHTTPCodeInstance2xxCount       MetricName = "HTTPCode_Instance_2XX_Count"
                                                                                                                                                                                                                                                                                                  	MetricNameHTTPCodeInstance3xxCount       MetricName = "HTTPCode_Instance_3XX_Count"
                                                                                                                                                                                                                                                                                                  	MetricNameHTTPCodeInstance4xxCount       MetricName = "HTTPCode_Instance_4XX_Count"
                                                                                                                                                                                                                                                                                                  	MetricNameHTTPCodeInstance5xxCount       MetricName = "HTTPCode_Instance_5XX_Count"
                                                                                                                                                                                                                                                                                                  	MetricNameInstanceResponseTime           MetricName = "InstanceResponseTime"
                                                                                                                                                                                                                                                                                                  	MetricNameRejectedConnectionCount        MetricName = "RejectedConnectionCount"
                                                                                                                                                                                                                                                                                                  	MetricNameRequestCount                   MetricName = "RequestCount"
                                                                                                                                                                                                                                                                                                  	MetricNameDatabaseConnections            MetricName = "DatabaseConnections"
                                                                                                                                                                                                                                                                                                  	MetricNameDiskQueueDepth                 MetricName = "DiskQueueDepth"
                                                                                                                                                                                                                                                                                                  	MetricNameFreeStorageSpace               MetricName = "FreeStorageSpace"
                                                                                                                                                                                                                                                                                                  	MetricNameNetworkReceiveThroughput       MetricName = "NetworkReceiveThroughput"
                                                                                                                                                                                                                                                                                                  	MetricNameNetworkTransmitThroughput      MetricName = "NetworkTransmitThroughput"
                                                                                                                                                                                                                                                                                                  	MetricNameBurstCapacityTime              MetricName = "BurstCapacityTime"
                                                                                                                                                                                                                                                                                                  	MetricNameBurstCapacityPercentage        MetricName = "BurstCapacityPercentage"
                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                    Enum values for MetricName

                                                                                                                                                                                                                                                                                                    func (MetricName) Values

                                                                                                                                                                                                                                                                                                    func (MetricName) Values() []MetricName

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

                                                                                                                                                                                                                                                                                                      type MetricStatistic

                                                                                                                                                                                                                                                                                                      type MetricStatistic string
                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                      	MetricStatisticMinimum     MetricStatistic = "Minimum"
                                                                                                                                                                                                                                                                                                      	MetricStatisticMaximum     MetricStatistic = "Maximum"
                                                                                                                                                                                                                                                                                                      	MetricStatisticSum         MetricStatistic = "Sum"
                                                                                                                                                                                                                                                                                                      	MetricStatisticAverage     MetricStatistic = "Average"
                                                                                                                                                                                                                                                                                                      	MetricStatisticSampleCount MetricStatistic = "SampleCount"
                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                        Enum values for MetricStatistic

                                                                                                                                                                                                                                                                                                        func (MetricStatistic) Values

                                                                                                                                                                                                                                                                                                        func (MetricStatistic) Values() []MetricStatistic

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

                                                                                                                                                                                                                                                                                                          type MetricUnit

                                                                                                                                                                                                                                                                                                          type MetricUnit string
                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                          	MetricUnitSeconds         MetricUnit = "Seconds"
                                                                                                                                                                                                                                                                                                          	MetricUnitMicroseconds    MetricUnit = "Microseconds"
                                                                                                                                                                                                                                                                                                          	MetricUnitMilliseconds    MetricUnit = "Milliseconds"
                                                                                                                                                                                                                                                                                                          	MetricUnitBytes           MetricUnit = "Bytes"
                                                                                                                                                                                                                                                                                                          	MetricUnitKilobytes       MetricUnit = "Kilobytes"
                                                                                                                                                                                                                                                                                                          	MetricUnitMegabytes       MetricUnit = "Megabytes"
                                                                                                                                                                                                                                                                                                          	MetricUnitGigabytes       MetricUnit = "Gigabytes"
                                                                                                                                                                                                                                                                                                          	MetricUnitTerabytes       MetricUnit = "Terabytes"
                                                                                                                                                                                                                                                                                                          	MetricUnitBits            MetricUnit = "Bits"
                                                                                                                                                                                                                                                                                                          	MetricUnitKilobits        MetricUnit = "Kilobits"
                                                                                                                                                                                                                                                                                                          	MetricUnitMegabits        MetricUnit = "Megabits"
                                                                                                                                                                                                                                                                                                          	MetricUnitGigabits        MetricUnit = "Gigabits"
                                                                                                                                                                                                                                                                                                          	MetricUnitTerabits        MetricUnit = "Terabits"
                                                                                                                                                                                                                                                                                                          	MetricUnitPercent         MetricUnit = "Percent"
                                                                                                                                                                                                                                                                                                          	MetricUnitCount           MetricUnit = "Count"
                                                                                                                                                                                                                                                                                                          	MetricUnitBytesSecond     MetricUnit = "Bytes/Second"
                                                                                                                                                                                                                                                                                                          	MetricUnitKilobytesSecond MetricUnit = "Kilobytes/Second"
                                                                                                                                                                                                                                                                                                          	MetricUnitMegabytesSecond MetricUnit = "Megabytes/Second"
                                                                                                                                                                                                                                                                                                          	MetricUnitGigabytesSecond MetricUnit = "Gigabytes/Second"
                                                                                                                                                                                                                                                                                                          	MetricUnitTerabytesSecond MetricUnit = "Terabytes/Second"
                                                                                                                                                                                                                                                                                                          	MetricUnitBitsSecond      MetricUnit = "Bits/Second"
                                                                                                                                                                                                                                                                                                          	MetricUnitKilobitsSecond  MetricUnit = "Kilobits/Second"
                                                                                                                                                                                                                                                                                                          	MetricUnitMegabitsSecond  MetricUnit = "Megabits/Second"
                                                                                                                                                                                                                                                                                                          	MetricUnitGigabitsSecond  MetricUnit = "Gigabits/Second"
                                                                                                                                                                                                                                                                                                          	MetricUnitTerabitsSecond  MetricUnit = "Terabits/Second"
                                                                                                                                                                                                                                                                                                          	MetricUnitCountSecond     MetricUnit = "Count/Second"
                                                                                                                                                                                                                                                                                                          	MetricUnitNone            MetricUnit = "None"
                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                            Enum values for MetricUnit

                                                                                                                                                                                                                                                                                                            func (MetricUnit) Values

                                                                                                                                                                                                                                                                                                            func (MetricUnit) Values() []MetricUnit

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

                                                                                                                                                                                                                                                                                                              type MonitoredResourceInfo

                                                                                                                                                                                                                                                                                                              type MonitoredResourceInfo struct {
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the resource being monitored.
                                                                                                                                                                                                                                                                                                              	Arn *string
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              	// The name of the Lightsail resource being monitored.
                                                                                                                                                                                                                                                                                                              	Name *string
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              	// The Lightsail resource type of the resource being monitored. Instances, load
                                                                                                                                                                                                                                                                                                              	// balancers, and relational databases are the only Lightsail resources that can
                                                                                                                                                                                                                                                                                                              	// currently be monitored by alarms.
                                                                                                                                                                                                                                                                                                              	ResourceType ResourceType
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                Describes resource being monitored by an alarm. An alarm is a way to monitor your Amazon Lightsail resource metrics. For more information, see Alarms in Amazon Lightsail (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-alarms).

                                                                                                                                                                                                                                                                                                                type MonthlyTransfer

                                                                                                                                                                                                                                                                                                                type MonthlyTransfer struct {
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// The amount allocated per month (in GB).
                                                                                                                                                                                                                                                                                                                	GbPerMonthAllocated *int32
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                  Describes the monthly data transfer in and out of your virtual private server (or instance).

                                                                                                                                                                                                                                                                                                                  type NetworkProtocol

                                                                                                                                                                                                                                                                                                                  type NetworkProtocol string
                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                  	NetworkProtocolTcp  NetworkProtocol = "tcp"
                                                                                                                                                                                                                                                                                                                  	NetworkProtocolAll  NetworkProtocol = "all"
                                                                                                                                                                                                                                                                                                                  	NetworkProtocolUdp  NetworkProtocol = "udp"
                                                                                                                                                                                                                                                                                                                  	NetworkProtocolIcmp NetworkProtocol = "icmp"
                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                    Enum values for NetworkProtocol

                                                                                                                                                                                                                                                                                                                    func (NetworkProtocol) Values

                                                                                                                                                                                                                                                                                                                    func (NetworkProtocol) Values() []NetworkProtocol

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

                                                                                                                                                                                                                                                                                                                      type NotFoundException

                                                                                                                                                                                                                                                                                                                      type NotFoundException struct {
                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	Code *string
                                                                                                                                                                                                                                                                                                                      	Docs *string
                                                                                                                                                                                                                                                                                                                      	Tip  *string
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        Lightsail throws this exception when it cannot find a resource.

                                                                                                                                                                                                                                                                                                                        func (*NotFoundException) Error

                                                                                                                                                                                                                                                                                                                        func (e *NotFoundException) Error() string

                                                                                                                                                                                                                                                                                                                        func (*NotFoundException) ErrorCode

                                                                                                                                                                                                                                                                                                                        func (e *NotFoundException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                        func (*NotFoundException) ErrorFault

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

                                                                                                                                                                                                                                                                                                                        func (*NotFoundException) ErrorMessage

                                                                                                                                                                                                                                                                                                                        func (e *NotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                        type Operation

                                                                                                                                                                                                                                                                                                                        type Operation struct {
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The timestamp when the operation was initialized (e.g., 1479816991.349).
                                                                                                                                                                                                                                                                                                                        	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The error code.
                                                                                                                                                                                                                                                                                                                        	ErrorCode *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The error details.
                                                                                                                                                                                                                                                                                                                        	ErrorDetails *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The ID of the operation.
                                                                                                                                                                                                                                                                                                                        	Id *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// A Boolean value indicating whether the operation is terminal.
                                                                                                                                                                                                                                                                                                                        	IsTerminal *bool
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The AWS Region and Availability Zone.
                                                                                                                                                                                                                                                                                                                        	Location *ResourceLocation
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// Details about the operation (e.g., Debian-1GB-Ohio-1).
                                                                                                                                                                                                                                                                                                                        	OperationDetails *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The type of operation.
                                                                                                                                                                                                                                                                                                                        	OperationType OperationType
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The resource name.
                                                                                                                                                                                                                                                                                                                        	ResourceName *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The resource type.
                                                                                                                                                                                                                                                                                                                        	ResourceType ResourceType
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The status of the operation.
                                                                                                                                                                                                                                                                                                                        	Status OperationStatus
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The timestamp when the status was changed (e.g., 1479816991.349).
                                                                                                                                                                                                                                                                                                                        	StatusChangedAt *time.Time
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          Describes the API operation.

                                                                                                                                                                                                                                                                                                                          type OperationFailureException

                                                                                                                                                                                                                                                                                                                          type OperationFailureException struct {
                                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          	Code *string
                                                                                                                                                                                                                                                                                                                          	Docs *string
                                                                                                                                                                                                                                                                                                                          	Tip  *string
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            Lightsail throws this exception when an operation fails to execute.

                                                                                                                                                                                                                                                                                                                            func (*OperationFailureException) Error

                                                                                                                                                                                                                                                                                                                            func (e *OperationFailureException) Error() string

                                                                                                                                                                                                                                                                                                                            func (*OperationFailureException) ErrorCode

                                                                                                                                                                                                                                                                                                                            func (e *OperationFailureException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                            func (*OperationFailureException) ErrorFault

                                                                                                                                                                                                                                                                                                                            func (*OperationFailureException) ErrorMessage

                                                                                                                                                                                                                                                                                                                            func (e *OperationFailureException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                            type OperationStatus

                                                                                                                                                                                                                                                                                                                            type OperationStatus string
                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                            	OperationStatusNotStarted OperationStatus = "NotStarted"
                                                                                                                                                                                                                                                                                                                            	OperationStatusStarted    OperationStatus = "Started"
                                                                                                                                                                                                                                                                                                                            	OperationStatusFailed     OperationStatus = "Failed"
                                                                                                                                                                                                                                                                                                                            	OperationStatusCompleted  OperationStatus = "Completed"
                                                                                                                                                                                                                                                                                                                            	OperationStatusSucceeded  OperationStatus = "Succeeded"
                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                              Enum values for OperationStatus

                                                                                                                                                                                                                                                                                                                              func (OperationStatus) Values

                                                                                                                                                                                                                                                                                                                              func (OperationStatus) Values() []OperationStatus

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

                                                                                                                                                                                                                                                                                                                                type OperationType

                                                                                                                                                                                                                                                                                                                                type OperationType string
                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteKnownHostKeys                  OperationType = "DeleteKnownHostKeys"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteInstance                       OperationType = "DeleteInstance"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateInstance                       OperationType = "CreateInstance"
                                                                                                                                                                                                                                                                                                                                	OperationTypeStopInstance                         OperationType = "StopInstance"
                                                                                                                                                                                                                                                                                                                                	OperationTypeStartInstance                        OperationType = "StartInstance"
                                                                                                                                                                                                                                                                                                                                	OperationTypeRebootInstance                       OperationType = "RebootInstance"
                                                                                                                                                                                                                                                                                                                                	OperationTypeOpenInstancePublicPorts              OperationType = "OpenInstancePublicPorts"
                                                                                                                                                                                                                                                                                                                                	OperationTypePutInstancePublicPorts               OperationType = "PutInstancePublicPorts"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCloseInstancePublicPorts             OperationType = "CloseInstancePublicPorts"
                                                                                                                                                                                                                                                                                                                                	OperationTypeAllocateStaticIp                     OperationType = "AllocateStaticIp"
                                                                                                                                                                                                                                                                                                                                	OperationTypeReleaseStaticIp                      OperationType = "ReleaseStaticIp"
                                                                                                                                                                                                                                                                                                                                	OperationTypeAttachStaticIp                       OperationType = "AttachStaticIp"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDetachStaticIp                       OperationType = "DetachStaticIp"
                                                                                                                                                                                                                                                                                                                                	OperationTypeUpdateDomainEntry                    OperationType = "UpdateDomainEntry"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteDomainEntry                    OperationType = "DeleteDomainEntry"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateDomain                         OperationType = "CreateDomain"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteDomain                         OperationType = "DeleteDomain"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateInstanceSnapshot               OperationType = "CreateInstanceSnapshot"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteInstanceSnapshot               OperationType = "DeleteInstanceSnapshot"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateInstancesFromSnapshot          OperationType = "CreateInstancesFromSnapshot"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateLoadBalancer                   OperationType = "CreateLoadBalancer"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteLoadBalancer                   OperationType = "DeleteLoadBalancer"
                                                                                                                                                                                                                                                                                                                                	OperationTypeAttachInstancesToLoadBalancer        OperationType = "AttachInstancesToLoadBalancer"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDetachInstancesFromLoadBalancer      OperationType = "DetachInstancesFromLoadBalancer"
                                                                                                                                                                                                                                                                                                                                	OperationTypeUpdateLoadBalancerAttribute          OperationType = "UpdateLoadBalancerAttribute"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateLoadBalancerTlsCertificate     OperationType = "CreateLoadBalancerTlsCertificate"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteLoadBalancerTlsCertificate     OperationType = "DeleteLoadBalancerTlsCertificate"
                                                                                                                                                                                                                                                                                                                                	OperationTypeAttachLoadBalancerTlsCertificate     OperationType = "AttachLoadBalancerTlsCertificate"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateDisk                           OperationType = "CreateDisk"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteDisk                           OperationType = "DeleteDisk"
                                                                                                                                                                                                                                                                                                                                	OperationTypeAttachDisk                           OperationType = "AttachDisk"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDetachDisk                           OperationType = "DetachDisk"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateDiskSnapshot                   OperationType = "CreateDiskSnapshot"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteDiskSnapshot                   OperationType = "DeleteDiskSnapshot"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateDiskFromSnapshot               OperationType = "CreateDiskFromSnapshot"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateRelationalDatabase             OperationType = "CreateRelationalDatabase"
                                                                                                                                                                                                                                                                                                                                	OperationTypeUpdateRelationalDatabase             OperationType = "UpdateRelationalDatabase"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteRelationalDatabase             OperationType = "DeleteRelationalDatabase"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateRelationalDatabaseFromSnapshot OperationType = "CreateRelationalDatabaseFromSnapshot"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateRelationalDatabaseSnapshot     OperationType = "CreateRelationalDatabaseSnapshot"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteRelationalDatabaseSnapshot     OperationType = "DeleteRelationalDatabaseSnapshot"
                                                                                                                                                                                                                                                                                                                                	OperationTypeUpdateRelationalDatabaseParameters   OperationType = "UpdateRelationalDatabaseParameters"
                                                                                                                                                                                                                                                                                                                                	OperationTypeStartRelationalDatabase              OperationType = "StartRelationalDatabase"
                                                                                                                                                                                                                                                                                                                                	OperationTypeRebootRelationalDatabase             OperationType = "RebootRelationalDatabase"
                                                                                                                                                                                                                                                                                                                                	OperationTypeStopRelationalDatabase               OperationType = "StopRelationalDatabase"
                                                                                                                                                                                                                                                                                                                                	OperationTypeEnableAddOn                          OperationType = "EnableAddOn"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDisableAddOn                         OperationType = "DisableAddOn"
                                                                                                                                                                                                                                                                                                                                	OperationTypePutAlarm                             OperationType = "PutAlarm"
                                                                                                                                                                                                                                                                                                                                	OperationTypeGetAlarms                            OperationType = "GetAlarms"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteAlarm                          OperationType = "DeleteAlarm"
                                                                                                                                                                                                                                                                                                                                	OperationTypeTestAlarm                            OperationType = "TestAlarm"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateContactMethod                  OperationType = "CreateContactMethod"
                                                                                                                                                                                                                                                                                                                                	OperationTypeGetContactMethods                    OperationType = "GetContactMethods"
                                                                                                                                                                                                                                                                                                                                	OperationTypeSendContactMethodVerification        OperationType = "SendContactMethodVerification"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteContactMethod                  OperationType = "DeleteContactMethod"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateDistribution                   OperationType = "CreateDistribution"
                                                                                                                                                                                                                                                                                                                                	OperationTypeUpdateDistribution                   OperationType = "UpdateDistribution"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteDistribution                   OperationType = "DeleteDistribution"
                                                                                                                                                                                                                                                                                                                                	OperationTypeResetDistributionCache               OperationType = "ResetDistributionCache"
                                                                                                                                                                                                                                                                                                                                	OperationTypeAttachCertificateToDistribution      OperationType = "AttachCertificateToDistribution"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDetachCertificateFromDistribution    OperationType = "DetachCertificateFromDistribution"
                                                                                                                                                                                                                                                                                                                                	OperationTypeUpdateDistributionBundle             OperationType = "UpdateDistributionBundle"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateCertificate                    OperationType = "CreateCertificate"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteCertificate                    OperationType = "DeleteCertificate"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateContainerService               OperationType = "CreateContainerService"
                                                                                                                                                                                                                                                                                                                                	OperationTypeUpdateContainerService               OperationType = "UpdateContainerService"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteContainerService               OperationType = "DeleteContainerService"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateContainerServiceDeployment     OperationType = "CreateContainerServiceDeployment"
                                                                                                                                                                                                                                                                                                                                	OperationTypeCreateContainerServiceRegistryLogin  OperationType = "CreateContainerServiceRegistryLogin"
                                                                                                                                                                                                                                                                                                                                	OperationTypeRegisterContainerImage               OperationType = "RegisterContainerImage"
                                                                                                                                                                                                                                                                                                                                	OperationTypeDeleteContainerImage                 OperationType = "DeleteContainerImage"
                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                  Enum values for OperationType

                                                                                                                                                                                                                                                                                                                                  func (OperationType) Values

                                                                                                                                                                                                                                                                                                                                  func (OperationType) Values() []OperationType

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

                                                                                                                                                                                                                                                                                                                                    type Origin

                                                                                                                                                                                                                                                                                                                                    type Origin struct {
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The name of the origin resource.
                                                                                                                                                                                                                                                                                                                                    	Name *string
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The protocol that your Amazon Lightsail distribution uses when establishing a
                                                                                                                                                                                                                                                                                                                                    	// connection with your origin to pull content.
                                                                                                                                                                                                                                                                                                                                    	ProtocolPolicy OriginProtocolPolicyEnum
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The AWS Region name of the origin resource.
                                                                                                                                                                                                                                                                                                                                    	RegionName RegionName
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The resource type of the origin resource (e.g., Instance).
                                                                                                                                                                                                                                                                                                                                    	ResourceType ResourceType
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      Describes the origin resource of an Amazon Lightsail content delivery network (CDN) distribution. An origin can be a Lightsail instance or load balancer. A distribution pulls content from an origin, caches it, and serves it to viewers via a worldwide network of edge servers.

                                                                                                                                                                                                                                                                                                                                      type OriginProtocolPolicyEnum

                                                                                                                                                                                                                                                                                                                                      type OriginProtocolPolicyEnum string
                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                      	OriginProtocolPolicyEnumHTTPOnly  OriginProtocolPolicyEnum = "http-only"
                                                                                                                                                                                                                                                                                                                                      	OriginProtocolPolicyEnumHTTPSOnly OriginProtocolPolicyEnum = "https-only"
                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                        Enum values for OriginProtocolPolicyEnum

                                                                                                                                                                                                                                                                                                                                        func (OriginProtocolPolicyEnum) Values

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

                                                                                                                                                                                                                                                                                                                                          type PasswordData

                                                                                                                                                                                                                                                                                                                                          type PasswordData struct {
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The encrypted password. Ciphertext will be an empty string if access to your new
                                                                                                                                                                                                                                                                                                                                          	// instance is not ready yet. When you create an instance, it can take up to 15
                                                                                                                                                                                                                                                                                                                                          	// minutes for the instance to be ready. If you use the default key pair
                                                                                                                                                                                                                                                                                                                                          	// (LightsailDefaultKeyPair), the decrypted password will be available in the
                                                                                                                                                                                                                                                                                                                                          	// password field. If you are using a custom key pair, you need to use your own
                                                                                                                                                                                                                                                                                                                                          	// means of decryption. If you change the Administrator password on the instance,
                                                                                                                                                                                                                                                                                                                                          	// Lightsail will continue to return the original ciphertext value. When accessing
                                                                                                                                                                                                                                                                                                                                          	// the instance using RDP, you need to manually enter the Administrator password
                                                                                                                                                                                                                                                                                                                                          	// after changing it from the default.
                                                                                                                                                                                                                                                                                                                                          	Ciphertext *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The name of the key pair that you used when creating your instance. If no key
                                                                                                                                                                                                                                                                                                                                          	// pair name was specified when creating the instance, Lightsail uses the default
                                                                                                                                                                                                                                                                                                                                          	// key pair (LightsailDefaultKeyPair). If you are using a custom key pair, you need
                                                                                                                                                                                                                                                                                                                                          	// to use your own means of decrypting your password using the ciphertext.
                                                                                                                                                                                                                                                                                                                                          	// Lightsail creates the ciphertext by encrypting your password with the public key
                                                                                                                                                                                                                                                                                                                                          	// part of this key pair.
                                                                                                                                                                                                                                                                                                                                          	KeyPairName *string
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            The password data for the Windows Server-based instance, including the ciphertext and the key pair name.

                                                                                                                                                                                                                                                                                                                                            type PendingMaintenanceAction

                                                                                                                                                                                                                                                                                                                                            type PendingMaintenanceAction struct {
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The type of pending database maintenance action.
                                                                                                                                                                                                                                                                                                                                            	Action *string
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The effective date of the pending database maintenance action.
                                                                                                                                                                                                                                                                                                                                            	CurrentApplyDate *time.Time
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// Additional detail about the pending database maintenance action.
                                                                                                                                                                                                                                                                                                                                            	Description *string
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                              Describes a pending database maintenance action.

                                                                                                                                                                                                                                                                                                                                              type PendingModifiedRelationalDatabaseValues

                                                                                                                                                                                                                                                                                                                                              type PendingModifiedRelationalDatabaseValues struct {
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// A Boolean value indicating whether automated backup retention is enabled.
                                                                                                                                                                                                                                                                                                                                              	BackupRetentionEnabled *bool
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The database engine version.
                                                                                                                                                                                                                                                                                                                                              	EngineVersion *string
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The password for the master user of the database.
                                                                                                                                                                                                                                                                                                                                              	MasterUserPassword *string
                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                Describes a pending database value modification.

                                                                                                                                                                                                                                                                                                                                                type PortAccessType

                                                                                                                                                                                                                                                                                                                                                type PortAccessType string
                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                	PortAccessTypePublic  PortAccessType = "Public"
                                                                                                                                                                                                                                                                                                                                                	PortAccessTypePrivate PortAccessType = "Private"
                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                  Enum values for PortAccessType

                                                                                                                                                                                                                                                                                                                                                  func (PortAccessType) Values

                                                                                                                                                                                                                                                                                                                                                  func (PortAccessType) Values() []PortAccessType

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

                                                                                                                                                                                                                                                                                                                                                    type PortInfo

                                                                                                                                                                                                                                                                                                                                                    type PortInfo struct {
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// An alias that defines access for a preconfigured range of IP addresses. The only
                                                                                                                                                                                                                                                                                                                                                    	// alias currently supported is lightsail-connect, which allows IP addresses of the
                                                                                                                                                                                                                                                                                                                                                    	// browser-based RDP/SSH client in the Lightsail console to connect to your
                                                                                                                                                                                                                                                                                                                                                    	// instance.
                                                                                                                                                                                                                                                                                                                                                    	CidrListAliases []string
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// The IP address, or range of IP addresses in CIDR notation, that are allowed to
                                                                                                                                                                                                                                                                                                                                                    	// connect to an instance through the ports, and the protocol. Lightsail supports
                                                                                                                                                                                                                                                                                                                                                    	// IPv4 addresses. Examples:
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * To allow the IP address 192.0.2.44, specify
                                                                                                                                                                                                                                                                                                                                                    	// 192.0.2.44 or 192.0.2.44/32.
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * To allow the IP addresses 192.0.2.0 to
                                                                                                                                                                                                                                                                                                                                                    	// 192.0.2.255, specify 192.0.2.0/24.
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// For more information about CIDR block
                                                                                                                                                                                                                                                                                                                                                    	// notation, see Classless Inter-Domain Routing
                                                                                                                                                                                                                                                                                                                                                    	// (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) on
                                                                                                                                                                                                                                                                                                                                                    	// Wikipedia.
                                                                                                                                                                                                                                                                                                                                                    	Cidrs []string
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// The first port in a range of open ports on an instance. Allowed ports:
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * TCP
                                                                                                                                                                                                                                                                                                                                                    	// and UDP - 0 to 65535
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * ICMP - The ICMP type. For example, specify 8 as the
                                                                                                                                                                                                                                                                                                                                                    	// fromPort (ICMP type), and -1 as the toPort (ICMP code), to enable ICMP Ping. For
                                                                                                                                                                                                                                                                                                                                                    	// more information, see Control Messages
                                                                                                                                                                                                                                                                                                                                                    	// (https://en.wikipedia.org/wiki/Internet_Control_Message_Protocol#Control_messages)
                                                                                                                                                                                                                                                                                                                                                    	// on Wikipedia.
                                                                                                                                                                                                                                                                                                                                                    	FromPort int32
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// The IP protocol name. The name can be one of the following:
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * tcp -
                                                                                                                                                                                                                                                                                                                                                    	// Transmission Control Protocol (TCP) provides reliable, ordered, and
                                                                                                                                                                                                                                                                                                                                                    	// error-checked delivery of streamed data between applications running on hosts
                                                                                                                                                                                                                                                                                                                                                    	// communicating by an IP network. If you have an application that doesn't require
                                                                                                                                                                                                                                                                                                                                                    	// reliable data stream service, use UDP instead.
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * all - All transport layer
                                                                                                                                                                                                                                                                                                                                                    	// protocol types. For more general information, see Transport layer
                                                                                                                                                                                                                                                                                                                                                    	// (https://en.wikipedia.org/wiki/Transport_layer) on Wikipedia.
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * udp - With User
                                                                                                                                                                                                                                                                                                                                                    	// Datagram Protocol (UDP), computer applications can send messages (or datagrams)
                                                                                                                                                                                                                                                                                                                                                    	// to other hosts on an Internet Protocol (IP) network. Prior communications are
                                                                                                                                                                                                                                                                                                                                                    	// not required to set up transmission channels or data paths. Applications that
                                                                                                                                                                                                                                                                                                                                                    	// don't require reliable data stream service can use UDP, which provides a
                                                                                                                                                                                                                                                                                                                                                    	// connectionless datagram service that emphasizes reduced latency over
                                                                                                                                                                                                                                                                                                                                                    	// reliability. If you do require reliable data stream service, use TCP instead.
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// *
                                                                                                                                                                                                                                                                                                                                                    	// icmp - Internet Control Message Protocol (ICMP) is used to send error messages
                                                                                                                                                                                                                                                                                                                                                    	// and operational information indicating success or failure when communicating
                                                                                                                                                                                                                                                                                                                                                    	// with an instance. For example, an error is indicated when an instance could not
                                                                                                                                                                                                                                                                                                                                                    	// be reached. When you specify icmp as the protocol, you must specify the ICMP
                                                                                                                                                                                                                                                                                                                                                    	// type using the fromPort parameter, and ICMP code using the toPort parameter.
                                                                                                                                                                                                                                                                                                                                                    	Protocol NetworkProtocol
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// The last port in a range of open ports on an instance. Allowed ports:
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * TCP and
                                                                                                                                                                                                                                                                                                                                                    	// UDP - 0 to 65535
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * ICMP - The ICMP code. For example, specify 8 as the fromPort
                                                                                                                                                                                                                                                                                                                                                    	// (ICMP type), and -1 as the toPort (ICMP code), to enable ICMP Ping. For more
                                                                                                                                                                                                                                                                                                                                                    	// information, see Control Messages
                                                                                                                                                                                                                                                                                                                                                    	// (https://en.wikipedia.org/wiki/Internet_Control_Message_Protocol#Control_messages)
                                                                                                                                                                                                                                                                                                                                                    	// on Wikipedia.
                                                                                                                                                                                                                                                                                                                                                    	ToPort int32
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                      Describes ports to open on an instance, the IP addresses allowed to connect to the instance through the ports, and the protocol.

                                                                                                                                                                                                                                                                                                                                                      type PortInfoSourceType

                                                                                                                                                                                                                                                                                                                                                      type PortInfoSourceType string
                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                      	PortInfoSourceTypeDefault  PortInfoSourceType = "DEFAULT"
                                                                                                                                                                                                                                                                                                                                                      	PortInfoSourceTypeInstance PortInfoSourceType = "INSTANCE"
                                                                                                                                                                                                                                                                                                                                                      	PortInfoSourceTypeNone     PortInfoSourceType = "NONE"
                                                                                                                                                                                                                                                                                                                                                      	PortInfoSourceTypeClosed   PortInfoSourceType = "CLOSED"
                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                        Enum values for PortInfoSourceType

                                                                                                                                                                                                                                                                                                                                                        func (PortInfoSourceType) Values

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

                                                                                                                                                                                                                                                                                                                                                          type PortState

                                                                                                                                                                                                                                                                                                                                                          type PortState string
                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                          	PortStateOpen   PortState = "open"
                                                                                                                                                                                                                                                                                                                                                          	PortStateClosed PortState = "closed"
                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                            Enum values for PortState

                                                                                                                                                                                                                                                                                                                                                            func (PortState) Values

                                                                                                                                                                                                                                                                                                                                                            func (PortState) Values() []PortState

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

                                                                                                                                                                                                                                                                                                                                                              type QueryStringObject

                                                                                                                                                                                                                                                                                                                                                              type QueryStringObject struct {
                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                              	// Indicates whether the distribution forwards and caches based on query strings.
                                                                                                                                                                                                                                                                                                                                                              	Option *bool
                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                              	// The specific query strings that the distribution forwards to the origin. Your
                                                                                                                                                                                                                                                                                                                                                              	// distribution will cache content based on the specified query strings. If the
                                                                                                                                                                                                                                                                                                                                                              	// option parameter is true, then your distribution forwards all query strings,
                                                                                                                                                                                                                                                                                                                                                              	// regardless of what you specify using the queryStringsAllowList parameter.
                                                                                                                                                                                                                                                                                                                                                              	QueryStringsAllowList []string
                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                Describes the query string parameters that an Amazon Lightsail content delivery network (CDN) distribution to bases caching on. For the query strings that you specify, your distribution caches separate versions of the specified content based on the query string values in viewer requests.

                                                                                                                                                                                                                                                                                                                                                                type RecordState

                                                                                                                                                                                                                                                                                                                                                                type RecordState string
                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                	RecordStateStarted   RecordState = "Started"
                                                                                                                                                                                                                                                                                                                                                                	RecordStateSucceeded RecordState = "Succeeded"
                                                                                                                                                                                                                                                                                                                                                                	RecordStateFailed    RecordState = "Failed"
                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                  Enum values for RecordState

                                                                                                                                                                                                                                                                                                                                                                  func (RecordState) Values

                                                                                                                                                                                                                                                                                                                                                                  func (RecordState) Values() []RecordState

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

                                                                                                                                                                                                                                                                                                                                                                    type Region

                                                                                                                                                                                                                                                                                                                                                                    type Region struct {
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The Availability Zones. Follows the format us-east-2a (case-sensitive).
                                                                                                                                                                                                                                                                                                                                                                    	AvailabilityZones []AvailabilityZone
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The continent code (e.g., NA, meaning North America).
                                                                                                                                                                                                                                                                                                                                                                    	ContinentCode *string
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The description of the AWS Region (e.g., This region is recommended to serve
                                                                                                                                                                                                                                                                                                                                                                    	// users in the eastern United States and eastern Canada).
                                                                                                                                                                                                                                                                                                                                                                    	Description *string
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The display name (e.g., Ohio).
                                                                                                                                                                                                                                                                                                                                                                    	DisplayName *string
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The region name (e.g., us-east-2).
                                                                                                                                                                                                                                                                                                                                                                    	Name RegionName
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The Availability Zones for databases. Follows the format us-east-2a
                                                                                                                                                                                                                                                                                                                                                                    	// (case-sensitive).
                                                                                                                                                                                                                                                                                                                                                                    	RelationalDatabaseAvailabilityZones []AvailabilityZone
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      Describes the AWS Region.

                                                                                                                                                                                                                                                                                                                                                                      type RegionName

                                                                                                                                                                                                                                                                                                                                                                      type RegionName string
                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameUsEast1      RegionName = "us-east-1"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameUsEast2      RegionName = "us-east-2"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameUsWest1      RegionName = "us-west-1"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameUsWest2      RegionName = "us-west-2"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameEuWest1      RegionName = "eu-west-1"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameEuWest2      RegionName = "eu-west-2"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameEuWest3      RegionName = "eu-west-3"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameEuCentral1   RegionName = "eu-central-1"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameCaCentral1   RegionName = "ca-central-1"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameApSouth1     RegionName = "ap-south-1"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameApSoutheast1 RegionName = "ap-southeast-1"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameApSoutheast2 RegionName = "ap-southeast-2"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameApNortheast1 RegionName = "ap-northeast-1"
                                                                                                                                                                                                                                                                                                                                                                      	RegionNameApNortheast2 RegionName = "ap-northeast-2"
                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                        Enum values for RegionName

                                                                                                                                                                                                                                                                                                                                                                        func (RegionName) Values

                                                                                                                                                                                                                                                                                                                                                                        func (RegionName) Values() []RegionName

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

                                                                                                                                                                                                                                                                                                                                                                          type RelationalDatabase

                                                                                                                                                                                                                                                                                                                                                                          type RelationalDatabase struct {
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the database.
                                                                                                                                                                                                                                                                                                                                                                          	Arn *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// A Boolean value indicating whether automated backup retention is enabled for the
                                                                                                                                                                                                                                                                                                                                                                          	// database.
                                                                                                                                                                                                                                                                                                                                                                          	BackupRetentionEnabled *bool
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The certificate associated with the database.
                                                                                                                                                                                                                                                                                                                                                                          	CaCertificateIdentifier *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The timestamp when the database was created. Formatted in Unix time.
                                                                                                                                                                                                                                                                                                                                                                          	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The database software (for example, MySQL).
                                                                                                                                                                                                                                                                                                                                                                          	Engine *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The database engine version (for example, 5.7.23).
                                                                                                                                                                                                                                                                                                                                                                          	EngineVersion *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// Describes the hardware of the database.
                                                                                                                                                                                                                                                                                                                                                                          	Hardware *RelationalDatabaseHardware
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The latest point in time to which the database can be restored. Formatted in
                                                                                                                                                                                                                                                                                                                                                                          	// Unix time.
                                                                                                                                                                                                                                                                                                                                                                          	LatestRestorableTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The Region name and Availability Zone where the database is located.
                                                                                                                                                                                                                                                                                                                                                                          	Location *ResourceLocation
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The name of the master database created when the Lightsail database resource is
                                                                                                                                                                                                                                                                                                                                                                          	// created.
                                                                                                                                                                                                                                                                                                                                                                          	MasterDatabaseName *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The master endpoint for the database.
                                                                                                                                                                                                                                                                                                                                                                          	MasterEndpoint *RelationalDatabaseEndpoint
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The master user name of the database.
                                                                                                                                                                                                                                                                                                                                                                          	MasterUsername *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The unique name of the database resource in Lightsail.
                                                                                                                                                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The status of parameter updates for the database.
                                                                                                                                                                                                                                                                                                                                                                          	ParameterApplyStatus *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// Describes the pending maintenance actions for the database.
                                                                                                                                                                                                                                                                                                                                                                          	PendingMaintenanceActions []PendingMaintenanceAction
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// Describes pending database value modifications.
                                                                                                                                                                                                                                                                                                                                                                          	PendingModifiedValues *PendingModifiedRelationalDatabaseValues
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The daily time range during which automated backups are created for the database
                                                                                                                                                                                                                                                                                                                                                                          	// (for example, 16:00-16:30).
                                                                                                                                                                                                                                                                                                                                                                          	PreferredBackupWindow *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The weekly time range during which system maintenance can occur on the database.
                                                                                                                                                                                                                                                                                                                                                                          	// In the format ddd:hh24:mi-ddd:hh24:mi. For example, Tue:17:00-Tue:17:30.
                                                                                                                                                                                                                                                                                                                                                                          	PreferredMaintenanceWindow *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// A Boolean value indicating whether the database is publicly accessible.
                                                                                                                                                                                                                                                                                                                                                                          	PubliclyAccessible *bool
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The blueprint ID for the database. A blueprint describes the major engine
                                                                                                                                                                                                                                                                                                                                                                          	// version of a database.
                                                                                                                                                                                                                                                                                                                                                                          	RelationalDatabaseBlueprintId *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The bundle ID for the database. A bundle describes the performance
                                                                                                                                                                                                                                                                                                                                                                          	// specifications for your database.
                                                                                                                                                                                                                                                                                                                                                                          	RelationalDatabaseBundleId *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The Lightsail resource type for the database (for example, RelationalDatabase).
                                                                                                                                                                                                                                                                                                                                                                          	ResourceType ResourceType
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// Describes the secondary Availability Zone of a high availability database. The
                                                                                                                                                                                                                                                                                                                                                                          	// secondary database is used for failover support of a high availability database.
                                                                                                                                                                                                                                                                                                                                                                          	SecondaryAvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// Describes the current state of the database.
                                                                                                                                                                                                                                                                                                                                                                          	State *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The support code for the database. Include this code in your email to support
                                                                                                                                                                                                                                                                                                                                                                          	// when you have questions about a database in Lightsail. This code enables our
                                                                                                                                                                                                                                                                                                                                                                          	// support team to look up your Lightsail information more easily.
                                                                                                                                                                                                                                                                                                                                                                          	SupportCode *string
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// The tag keys and optional values for the resource. For more information about
                                                                                                                                                                                                                                                                                                                                                                          	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                                                                                                                                                                                                                                                                                                          	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                                                                                                                                                                                                                                                                                                          	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                            Describes a database.

                                                                                                                                                                                                                                                                                                                                                                            type RelationalDatabaseBlueprint

                                                                                                                                                                                                                                                                                                                                                                            type RelationalDatabaseBlueprint struct {
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The ID for the database blueprint.
                                                                                                                                                                                                                                                                                                                                                                            	BlueprintId *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The database software of the database blueprint (for example, MySQL).
                                                                                                                                                                                                                                                                                                                                                                            	Engine RelationalDatabaseEngine
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The description of the database engine for the database blueprint.
                                                                                                                                                                                                                                                                                                                                                                            	EngineDescription *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The database engine version for the database blueprint (for example, 5.7.23).
                                                                                                                                                                                                                                                                                                                                                                            	EngineVersion *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// The description of the database engine version for the database blueprint.
                                                                                                                                                                                                                                                                                                                                                                            	EngineVersionDescription *string
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// A Boolean value indicating whether the engine version is the default for the
                                                                                                                                                                                                                                                                                                                                                                            	// database blueprint.
                                                                                                                                                                                                                                                                                                                                                                            	IsEngineDefault *bool
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              Describes a database image, or blueprint. A blueprint describes the major engine version of a database.

                                                                                                                                                                                                                                                                                                                                                                              type RelationalDatabaseBundle

                                                                                                                                                                                                                                                                                                                                                                              type RelationalDatabaseBundle struct {
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// The ID for the database bundle.
                                                                                                                                                                                                                                                                                                                                                                              	BundleId *string
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// The number of virtual CPUs (vCPUs) for the database bundle.
                                                                                                                                                                                                                                                                                                                                                                              	CpuCount *int32
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// The size of the disk for the database bundle.
                                                                                                                                                                                                                                                                                                                                                                              	DiskSizeInGb *int32
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// A Boolean value indicating whether the database bundle is active.
                                                                                                                                                                                                                                                                                                                                                                              	IsActive *bool
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// A Boolean value indicating whether the database bundle is encrypted.
                                                                                                                                                                                                                                                                                                                                                                              	IsEncrypted *bool
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// The name for the database bundle.
                                                                                                                                                                                                                                                                                                                                                                              	Name *string
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// The cost of the database bundle in US currency.
                                                                                                                                                                                                                                                                                                                                                                              	Price *float32
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// The amount of RAM in GB (for example, 2.0) for the database bundle.
                                                                                                                                                                                                                                                                                                                                                                              	RamSizeInGb *float32
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// The data transfer rate per month in GB for the database bundle.
                                                                                                                                                                                                                                                                                                                                                                              	TransferPerMonthInGb *int32
                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                Describes a database bundle. A bundle describes the performance specifications of the database.

                                                                                                                                                                                                                                                                                                                                                                                type RelationalDatabaseEndpoint

                                                                                                                                                                                                                                                                                                                                                                                type RelationalDatabaseEndpoint struct {
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// Specifies the DNS address of the database.
                                                                                                                                                                                                                                                                                                                                                                                	Address *string
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// Specifies the port that the database is listening on.
                                                                                                                                                                                                                                                                                                                                                                                	Port *int32
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                  Describes an endpoint for a database.

                                                                                                                                                                                                                                                                                                                                                                                  type RelationalDatabaseEngine

                                                                                                                                                                                                                                                                                                                                                                                  type RelationalDatabaseEngine string
                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                  	RelationalDatabaseEngineMysql RelationalDatabaseEngine = "mysql"
                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                    Enum values for RelationalDatabaseEngine

                                                                                                                                                                                                                                                                                                                                                                                    func (RelationalDatabaseEngine) Values

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

                                                                                                                                                                                                                                                                                                                                                                                      type RelationalDatabaseEvent

                                                                                                                                                                                                                                                                                                                                                                                      type RelationalDatabaseEvent struct {
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// The timestamp when the database event was created.
                                                                                                                                                                                                                                                                                                                                                                                      	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// The category that the database event belongs to.
                                                                                                                                                                                                                                                                                                                                                                                      	EventCategories []string
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// The message of the database event.
                                                                                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// The database that the database event relates to.
                                                                                                                                                                                                                                                                                                                                                                                      	Resource *string
                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                        Describes an event for a database.

                                                                                                                                                                                                                                                                                                                                                                                        type RelationalDatabaseHardware

                                                                                                                                                                                                                                                                                                                                                                                        type RelationalDatabaseHardware struct {
                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                        	// The number of vCPUs for the database.
                                                                                                                                                                                                                                                                                                                                                                                        	CpuCount *int32
                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                        	// The size of the disk for the database.
                                                                                                                                                                                                                                                                                                                                                                                        	DiskSizeInGb *int32
                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                        	// The amount of RAM in GB for the database.
                                                                                                                                                                                                                                                                                                                                                                                        	RamSizeInGb *float32
                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                          Describes the hardware of a database.

                                                                                                                                                                                                                                                                                                                                                                                          type RelationalDatabaseMetricName

                                                                                                                                                                                                                                                                                                                                                                                          type RelationalDatabaseMetricName string
                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                          	RelationalDatabaseMetricNameCPUUtilization            RelationalDatabaseMetricName = "CPUUtilization"
                                                                                                                                                                                                                                                                                                                                                                                          	RelationalDatabaseMetricNameDatabaseConnections       RelationalDatabaseMetricName = "DatabaseConnections"
                                                                                                                                                                                                                                                                                                                                                                                          	RelationalDatabaseMetricNameDiskQueueDepth            RelationalDatabaseMetricName = "DiskQueueDepth"
                                                                                                                                                                                                                                                                                                                                                                                          	RelationalDatabaseMetricNameFreeStorageSpace          RelationalDatabaseMetricName = "FreeStorageSpace"
                                                                                                                                                                                                                                                                                                                                                                                          	RelationalDatabaseMetricNameNetworkReceiveThroughput  RelationalDatabaseMetricName = "NetworkReceiveThroughput"
                                                                                                                                                                                                                                                                                                                                                                                          	RelationalDatabaseMetricNameNetworkTransmitThroughput RelationalDatabaseMetricName = "NetworkTransmitThroughput"
                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                            Enum values for RelationalDatabaseMetricName

                                                                                                                                                                                                                                                                                                                                                                                            func (RelationalDatabaseMetricName) Values

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

                                                                                                                                                                                                                                                                                                                                                                                              type RelationalDatabaseParameter

                                                                                                                                                                                                                                                                                                                                                                                              type RelationalDatabaseParameter struct {
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// Specifies the valid range of values for the parameter.
                                                                                                                                                                                                                                                                                                                                                                                              	AllowedValues *string
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// Indicates when parameter updates are applied. Can be immediate or
                                                                                                                                                                                                                                                                                                                                                                                              	// pending-reboot.
                                                                                                                                                                                                                                                                                                                                                                                              	ApplyMethod *string
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// Specifies the engine-specific parameter type.
                                                                                                                                                                                                                                                                                                                                                                                              	ApplyType *string
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// Specifies the valid data type for the parameter.
                                                                                                                                                                                                                                                                                                                                                                                              	DataType *string
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// Provides a description of the parameter.
                                                                                                                                                                                                                                                                                                                                                                                              	Description *string
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// A Boolean value indicating whether the parameter can be modified.
                                                                                                                                                                                                                                                                                                                                                                                              	IsModifiable *bool
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// Specifies the name of the parameter.
                                                                                                                                                                                                                                                                                                                                                                                              	ParameterName *string
                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                              	// Specifies the value of the parameter.
                                                                                                                                                                                                                                                                                                                                                                                              	ParameterValue *string
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                Describes the parameters of a database.

                                                                                                                                                                                                                                                                                                                                                                                                type RelationalDatabasePasswordVersion

                                                                                                                                                                                                                                                                                                                                                                                                type RelationalDatabasePasswordVersion string
                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                	RelationalDatabasePasswordVersionCurrent  RelationalDatabasePasswordVersion = "CURRENT"
                                                                                                                                                                                                                                                                                                                                                                                                	RelationalDatabasePasswordVersionPrevious RelationalDatabasePasswordVersion = "PREVIOUS"
                                                                                                                                                                                                                                                                                                                                                                                                	RelationalDatabasePasswordVersionPending  RelationalDatabasePasswordVersion = "PENDING"
                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for RelationalDatabasePasswordVersion

                                                                                                                                                                                                                                                                                                                                                                                                  func (RelationalDatabasePasswordVersion) Values

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

                                                                                                                                                                                                                                                                                                                                                                                                    type RelationalDatabaseSnapshot

                                                                                                                                                                                                                                                                                                                                                                                                    type RelationalDatabaseSnapshot struct {
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the database snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                    	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The timestamp when the database snapshot was created.
                                                                                                                                                                                                                                                                                                                                                                                                    	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The software of the database snapshot (for example, MySQL)
                                                                                                                                                                                                                                                                                                                                                                                                    	Engine *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The database engine version for the database snapshot (for example, 5.7.23).
                                                                                                                                                                                                                                                                                                                                                                                                    	EngineVersion *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the database from which the database snapshot
                                                                                                                                                                                                                                                                                                                                                                                                    	// was created.
                                                                                                                                                                                                                                                                                                                                                                                                    	FromRelationalDatabaseArn *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The blueprint ID of the database from which the database snapshot was created. A
                                                                                                                                                                                                                                                                                                                                                                                                    	// blueprint describes the major engine version of a database.
                                                                                                                                                                                                                                                                                                                                                                                                    	FromRelationalDatabaseBlueprintId *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The bundle ID of the database from which the database snapshot was created.
                                                                                                                                                                                                                                                                                                                                                                                                    	FromRelationalDatabaseBundleId *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the source database from which the database snapshot was created.
                                                                                                                                                                                                                                                                                                                                                                                                    	FromRelationalDatabaseName *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The Region name and Availability Zone where the database snapshot is located.
                                                                                                                                                                                                                                                                                                                                                                                                    	Location *ResourceLocation
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the database snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                    	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The Lightsail resource type.
                                                                                                                                                                                                                                                                                                                                                                                                    	ResourceType ResourceType
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The size of the disk in GB (for example, 32) for the database snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                    	SizeInGb *int32
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The state of the database snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                    	State *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The support code for the database snapshot. Include this code in your email to
                                                                                                                                                                                                                                                                                                                                                                                                    	// support when you have questions about a database snapshot in Lightsail. This
                                                                                                                                                                                                                                                                                                                                                                                                    	// code enables our support team to look up your Lightsail information more easily.
                                                                                                                                                                                                                                                                                                                                                                                                    	SupportCode *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The tag keys and optional values for the resource. For more information about
                                                                                                                                                                                                                                                                                                                                                                                                    	// tags in Lightsail, see the Lightsail Dev Guide
                                                                                                                                                                                                                                                                                                                                                                                                    	// (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
                                                                                                                                                                                                                                                                                                                                                                                                    	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      Describes a database snapshot.

                                                                                                                                                                                                                                                                                                                                                                                                      type RenewalStatus

                                                                                                                                                                                                                                                                                                                                                                                                      type RenewalStatus string
                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                      	RenewalStatusPendingAutoRenewal RenewalStatus = "PendingAutoRenewal"
                                                                                                                                                                                                                                                                                                                                                                                                      	RenewalStatusPendingValidation  RenewalStatus = "PendingValidation"
                                                                                                                                                                                                                                                                                                                                                                                                      	RenewalStatusSuccess            RenewalStatus = "Success"
                                                                                                                                                                                                                                                                                                                                                                                                      	RenewalStatusFailed             RenewalStatus = "Failed"
                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for RenewalStatus

                                                                                                                                                                                                                                                                                                                                                                                                        func (RenewalStatus) Values

                                                                                                                                                                                                                                                                                                                                                                                                        func (RenewalStatus) Values() []RenewalStatus

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

                                                                                                                                                                                                                                                                                                                                                                                                          type RenewalSummary

                                                                                                                                                                                                                                                                                                                                                                                                          type RenewalSummary struct {
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// An array of objects that describe the domain validation records of the
                                                                                                                                                                                                                                                                                                                                                                                                          	// certificate.
                                                                                                                                                                                                                                                                                                                                                                                                          	DomainValidationRecords []DomainValidationRecord
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The renewal status of the certificate. The following renewal status are
                                                                                                                                                                                                                                                                                                                                                                                                          	// possible:
                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                          	// * PendingAutoRenewal - Lightsail is attempting to automatically
                                                                                                                                                                                                                                                                                                                                                                                                          	// validate the domain names of the certificate. No further action is required.
                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                          	// *
                                                                                                                                                                                                                                                                                                                                                                                                          	// PendingValidation - Lightsail couldn't automatically validate one or more domain
                                                                                                                                                                                                                                                                                                                                                                                                          	// names of the certificate. You must take action to validate these domain names or
                                                                                                                                                                                                                                                                                                                                                                                                          	// the certificate won't be renewed. Check to make sure your certificate's domain
                                                                                                                                                                                                                                                                                                                                                                                                          	// validation records exist in your domain's DNS, and that your certificate remains
                                                                                                                                                                                                                                                                                                                                                                                                          	// in use.
                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                          	// * Success - All domain names in the certificate are validated, and
                                                                                                                                                                                                                                                                                                                                                                                                          	// Lightsail renewed the certificate. No further action is required.
                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                          	// * Failed -
                                                                                                                                                                                                                                                                                                                                                                                                          	// One or more domain names were not validated before the certificate expired, and
                                                                                                                                                                                                                                                                                                                                                                                                          	// Lightsail did not renew the certificate. You can request a new certificate using
                                                                                                                                                                                                                                                                                                                                                                                                          	// the CreateCertificate action.
                                                                                                                                                                                                                                                                                                                                                                                                          	RenewalStatus RenewalStatus
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The reason for the renewal status of the certificate.
                                                                                                                                                                                                                                                                                                                                                                                                          	RenewalStatusReason *string
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The timestamp when the certificate was last updated.
                                                                                                                                                                                                                                                                                                                                                                                                          	UpdatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                            Describes the status of a SSL/TLS certificate renewal managed by Amazon Lightsail.

                                                                                                                                                                                                                                                                                                                                                                                                            type ResourceLocation

                                                                                                                                                                                                                                                                                                                                                                                                            type ResourceLocation struct {
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// The Availability Zone. Follows the format us-east-2a (case-sensitive).
                                                                                                                                                                                                                                                                                                                                                                                                            	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// The AWS Region name.
                                                                                                                                                                                                                                                                                                                                                                                                            	RegionName RegionName
                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                              Describes the resource location.

                                                                                                                                                                                                                                                                                                                                                                                                              type ResourceRecord

                                                                                                                                                                                                                                                                                                                                                                                                              type ResourceRecord struct {
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The name of the record.
                                                                                                                                                                                                                                                                                                                                                                                                              	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The DNS record type.
                                                                                                                                                                                                                                                                                                                                                                                                              	Type *string
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The value for the DNS record.
                                                                                                                                                                                                                                                                                                                                                                                                              	Value *string
                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                Describes the domain name system (DNS) records to add to your domain's DNS to validate it for an Amazon Lightsail certificate.

                                                                                                                                                                                                                                                                                                                                                                                                                type ResourceType

                                                                                                                                                                                                                                                                                                                                                                                                                type ResourceType string
                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeContainerService           ResourceType = "ContainerService"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeInstance                   ResourceType = "Instance"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeStaticIp                   ResourceType = "StaticIp"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeKeyPair                    ResourceType = "KeyPair"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeInstanceSnapshot           ResourceType = "InstanceSnapshot"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeDomain                     ResourceType = "Domain"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypePeeredVpc                  ResourceType = "PeeredVpc"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeLoadBalancer               ResourceType = "LoadBalancer"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeLoadBalancerTlsCertificate ResourceType = "LoadBalancerTlsCertificate"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeDisk                       ResourceType = "Disk"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeDiskSnapshot               ResourceType = "DiskSnapshot"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeRelationalDatabase         ResourceType = "RelationalDatabase"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeRelationalDatabaseSnapshot ResourceType = "RelationalDatabaseSnapshot"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeExportSnapshotRecord       ResourceType = "ExportSnapshotRecord"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeCloudFormationStackRecord  ResourceType = "CloudFormationStackRecord"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeAlarm                      ResourceType = "Alarm"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeContactMethod              ResourceType = "ContactMethod"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeDistribution               ResourceType = "Distribution"
                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceTypeCertificate                ResourceType = "Certificate"
                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for ResourceType

                                                                                                                                                                                                                                                                                                                                                                                                                  func (ResourceType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                  func (ResourceType) Values() []ResourceType

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

                                                                                                                                                                                                                                                                                                                                                                                                                    type ServiceException

                                                                                                                                                                                                                                                                                                                                                                                                                    type ServiceException struct {
                                                                                                                                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                    	Code *string
                                                                                                                                                                                                                                                                                                                                                                                                                    	Docs *string
                                                                                                                                                                                                                                                                                                                                                                                                                    	Tip  *string
                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                      A general service exception.

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ServiceException) Error

                                                                                                                                                                                                                                                                                                                                                                                                                      func (e *ServiceException) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ServiceException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                                      func (e *ServiceException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ServiceException) ErrorFault

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

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ServiceException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                      func (e *ServiceException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                                      type StaticIp

                                                                                                                                                                                                                                                                                                                                                                                                                      type StaticIp struct {
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) of the static IP (e.g.,
                                                                                                                                                                                                                                                                                                                                                                                                                      	// arn:aws:lightsail:us-east-2:123456789101:StaticIp/9cbb4a9e-f8e3-4dfe-b57e-12345EXAMPLE).
                                                                                                                                                                                                                                                                                                                                                                                                                      	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// The instance where the static IP is attached (e.g., Amazon_Linux-1GB-Ohio-1).
                                                                                                                                                                                                                                                                                                                                                                                                                      	AttachedTo *string
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// The timestamp when the static IP was created (e.g., 1479735304.222).
                                                                                                                                                                                                                                                                                                                                                                                                                      	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// The static IP address.
                                                                                                                                                                                                                                                                                                                                                                                                                      	IpAddress *string
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// A Boolean value indicating whether the static IP is attached.
                                                                                                                                                                                                                                                                                                                                                                                                                      	IsAttached *bool
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// The region and Availability Zone where the static IP was created.
                                                                                                                                                                                                                                                                                                                                                                                                                      	Location *ResourceLocation
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the static IP (e.g., StaticIP-Ohio-EXAMPLE).
                                                                                                                                                                                                                                                                                                                                                                                                                      	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// The resource type (usually StaticIp).
                                                                                                                                                                                                                                                                                                                                                                                                                      	ResourceType ResourceType
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// The support code. Include this code in your email to support when you have
                                                                                                                                                                                                                                                                                                                                                                                                                      	// questions about an instance or another resource in Lightsail. This code enables
                                                                                                                                                                                                                                                                                                                                                                                                                      	// our support team to look up your Lightsail information more easily.
                                                                                                                                                                                                                                                                                                                                                                                                                      	SupportCode *string
                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                        Describes the static IP.

                                                                                                                                                                                                                                                                                                                                                                                                                        type Tag

                                                                                                                                                                                                                                                                                                                                                                                                                        type Tag struct {
                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                        	// The key of the tag. Constraints: Tag keys accept a maximum of 128 letters,
                                                                                                                                                                                                                                                                                                                                                                                                                        	// numbers, spaces in UTF-8, or the following characters: + - = . _ : / @
                                                                                                                                                                                                                                                                                                                                                                                                                        	Key *string
                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                        	// The value of the tag. Constraints: Tag values accept a maximum of 256 letters,
                                                                                                                                                                                                                                                                                                                                                                                                                        	// numbers, spaces in UTF-8, or the following characters: + - = . _ : / @
                                                                                                                                                                                                                                                                                                                                                                                                                        	Value *string
                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                          Describes a tag key and optional value assigned to an Amazon Lightsail resource. For more information about tags in Lightsail, see the Lightsail Dev Guide (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).

                                                                                                                                                                                                                                                                                                                                                                                                                          type TreatMissingData

                                                                                                                                                                                                                                                                                                                                                                                                                          type TreatMissingData string
                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                          	TreatMissingDataBreaching    TreatMissingData = "breaching"
                                                                                                                                                                                                                                                                                                                                                                                                                          	TreatMissingDataNotBreaching TreatMissingData = "notBreaching"
                                                                                                                                                                                                                                                                                                                                                                                                                          	TreatMissingDataIgnore       TreatMissingData = "ignore"
                                                                                                                                                                                                                                                                                                                                                                                                                          	TreatMissingDataMissing      TreatMissingData = "missing"
                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for TreatMissingData

                                                                                                                                                                                                                                                                                                                                                                                                                            func (TreatMissingData) Values

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

                                                                                                                                                                                                                                                                                                                                                                                                                              type UnauthenticatedException

                                                                                                                                                                                                                                                                                                                                                                                                                              type UnauthenticatedException struct {
                                                                                                                                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                              	Code *string
                                                                                                                                                                                                                                                                                                                                                                                                                              	Docs *string
                                                                                                                                                                                                                                                                                                                                                                                                                              	Tip  *string
                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                Lightsail throws this exception when the user has not been authenticated.

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*UnauthenticatedException) Error

                                                                                                                                                                                                                                                                                                                                                                                                                                func (e *UnauthenticatedException) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*UnauthenticatedException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                                                func (e *UnauthenticatedException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*UnauthenticatedException) ErrorFault

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

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*UnauthenticatedException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                func (e *UnauthenticatedException) ErrorMessage() string