type AccessDeniedException struct {
	Message *string

	Tip  *string
	Code *string
	Docs *string
}

type AccessDirection string

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

type AccountSetupInProgressException struct {
	Message *string

	Docs *string
	Code *string
	Tip  *string
}

type AddOn struct {

	// 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 name of the add-on.
	Name *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
}

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
}

type AddOnType string

const (
	AddOnTypeAutosnapshot AddOnType = "AutoSnapshot"
)

type Alarm struct {

	// 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

	// An object that lists information about the location of the alarm.
	Location *ResourceLocation

	// The value against which the specified statistic is compared.
	Threshold *float64

	// The alarm states that trigger a notification.
	NotificationTriggers []AlarmState

	// The unit of the metric associated with the alarm.
	Unit MetricUnit

	// The name of the metric associated with the alarm.
	MetricName MetricName

	// The contact protocols for the alarm, such as Email, SMS (text messaging), or
	// both.
	ContactProtocols []ContactProtocol

	// The arithmetic operation used when comparing the specified statistic and
	// threshold.
	ComparisonOperator ComparisonOperator

	// The number of data points that must not within the specified threshold to
	// trigger the alarm.
	DatapointsToAlarm *int32

	// 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 Lightsail resource type (e.g., Alarm).
	ResourceType ResourceType

	// The name of the alarm.
	Name *string

	// The number of periods over which data is compared to the specified threshold.
	EvaluationPeriods *int32

	// The Amazon Resource Name (ARN) of the alarm.
	Arn *string

	// Indicates whether the alarm is enabled.
	NotificationEnabled *bool

	// The period, in seconds, over which the statistic is applied.
	Period *int32

	// 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 timestamp when the alarm was created.
	CreatedAt *time.Time

	// 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

	// An object that lists information about the resource monitored by the alarm.
	MonitoredResourceInfo *MonitoredResourceInfo
}

type AlarmState string

const (
	AlarmStateOk                AlarmState = "OK"
	AlarmStateAlarm             AlarmState = "ALARM"
	AlarmStateInsufficient_data AlarmState = "INSUFFICIENT_DATA"
)

type AttachedDisk struct {

	// The path of the disk (e.g., /dev/xvdf).
	Path *string

	// The size of the disk in GB.
	SizeInGb *int32
}

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
}

type AutoSnapshotDetails struct {

	// The status of the automatic snapshot.
	Status AutoSnapshotStatus

	// An array of objects that describe the block storage disks attached to the
	// instance when the automatic snapshot was created.
	FromAttachedDisks []*AttachedDisk

	// The timestamp when the automatic snapshot was created.
	CreatedAt *time.Time

	// The date of the automatic snapshot in YYYY-MM-DD format.
	Date *string
}

type AutoSnapshotStatus string

const (
	AutoSnapshotStatusSuccess     AutoSnapshotStatus = "Success"
	AutoSnapshotStatusFailed      AutoSnapshotStatus = "Failed"
	AutoSnapshotStatusIn_progress AutoSnapshotStatus = "InProgress"
	AutoSnapshotStatusNot_found   AutoSnapshotStatus = "NotFound"
)

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
}

type BehaviorEnum string

const (
	BehaviorEnumDontcachesetting BehaviorEnum = "dont-cache"
	BehaviorEnumCachesetting     BehaviorEnum = "cache"
)

type Blueprint struct {

	// The friendly name of the blueprint (e.g., Amazon Linux).
	Name *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 version number of the operating system, application, or stack (e.g.,
	// 2016.03.0).
	Version *string

	// 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 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 group name of the blueprint (e.g., amazon-linux).
	Group *string

	// The version code.
	VersionCode *string

	// The operating system platform (either Linux/Unix-based or Windows Server-based)
	// of the blueprint.
	Platform InstancePlatform

	// The description of the blueprint.
	Description *string

	// The ID for the virtual private server image (e.g., app_wordpress_4_4 or
	// app_lamp_7_0).
	BlueprintId *string
}

type BlueprintType string

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

type Bundle struct {

	// The number of vCPUs included in the bundle (e.g., 2).
	CpuCount *int32

	// The price in US dollars (e.g., 5.0) of the bundle.
	Price *float32

	// The Amazon EC2 instance type (e.g., t2.micro).
	InstanceType *string

	// A Boolean value indicating whether the bundle is active.
	IsActive *bool

	// The data transfer rate per month in GB (e.g., 2000).
	TransferPerMonthInGb *int32

	// 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 size of the SSD (e.g., 30).
	DiskSizeInGb *int32

	// The bundle ID (e.g., micro_1_0).
	BundleId *string

	// 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

	// A friendly name for the bundle (e.g., Micro).
	Name *string

	// The amount of RAM in GB (e.g., 2.0).
	RamSizeInGb *float32
}

type CacheBehavior struct {

	// The cache behavior of the distribution.  <p>The following cache behaviors can be
	// specified:</p> <ul> <li> <p> <b> <code>cache</code> </b> - 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.</p>
	// </li> <li> <p> <b> <code>dont-cache</code> </b> - 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 <code>CacheBehaviorPerPath</code> parameter. This behavior is
	// ideal for websites or web applications that use cookies, headers, and query
	// strings to personalize content for individual users.</p> </li> </ul>
	Behavior BehaviorEnum
}

type CacheBehaviorPerPath struct {

	// The cache behavior for the specified path.  <p>You can specify one of the
	// following per-path cache behaviors:</p> <ul> <li> <p> <b> <code>cache</code>
	// </b> - This behavior caches the specified path. </p> </li> <li> <p> <b>
	// <code>dont-cache</code> </b> - This behavior doesn't cache the specified path.
	// </p> </li> </ul>
	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.  <p>Examples:</p>
	// <ul> <li> <p>Specify the following to cache all files in the document root of an
	// Apache web server running on a Lightsail instance.</p> <p>
	// <code>var/www/html/</code> </p> </li> <li> <p>Specify the following file to
	// cache only the index page in the document root of an Apache web server.</p> <p>
	// <code>var/www/html/index.html</code> </p> </li> <li> <p>Specify the following to
	// cache only the .html files in the document root of an Apache web server.</p> <p>
	// <code>var/www/html/*.html</code> </p> </li> <li> <p>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.</p> <p>
	// <code>var/www/html/images/*.jpg</code> </p> <p>
	// <code>var/www/html/images/*.png</code> </p> <p>
	// <code>var/www/html/images/*.gif</code> </p> <p>Specify the following to cache
	// all files in the images sub-directory of the document root of an Apache web
	// server.</p> <p> <code>var/www/html/images/</code> </p> </li> </ul>
	Path *string
}

type CacheSettings struct {

	// 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

	// 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.  <note> <p>The value specified applies only when the
	// origin does not add HTTP headers such as <code>Cache-Control max-age</code>,
	// <code>Cache-Control s-maxage</code>, and <code>Expires</code> to objects.</p>
	// </note>
	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

	// 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.  <p>A value of <code>0</code> must be specified for
	// <code>minimumTTL</code> if the distribution is configured to forward all headers
	// to the origin.</p>
	MinimumTTL *int64

	// The HTTP methods that are processed and forwarded to the distribution's origin.
	// <p>You can specify the following options:</p> <ul> <li> <p>
	// <code>GET,HEAD</code> - The distribution forwards the <code>GET</code> and
	// <code>HEAD</code> methods.</p> </li> <li> <p> <code>GET,HEAD,OPTIONS</code> -
	// The distribution forwards the <code>GET</code>, <code>HEAD</code>, and
	// <code>OPTIONS</code> methods.</p> </li> <li> <p>
	// <code>GET,HEAD,OPTIONS,PUT,PATCH,POST,DELETE</code> - The distribution forwards
	// the <code>GET</code>, <code>HEAD</code>, <code>OPTIONS</code>, <code>PUT</code>,
	// <code>PATCH</code>, <code>POST</code>, and <code>DELETE</code> methods.</p>
	// </li> </ul> <p>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.</p>
	AllowedHTTPMethods *string

	// The HTTP method responses that are cached by your distribution.  <p>You can
	// specify the following options:</p> <ul> <li> <p> <code>GET,HEAD</code> - The
	// distribution caches responses to the <code>GET</code> and <code>HEAD</code>
	// methods.</p> </li> <li> <p> <code>GET,HEAD,OPTIONS</code> - The distribution
	// caches responses to the <code>GET</code>, <code>HEAD</code>, and
	// <code>OPTIONS</code> methods.</p> </li> </ul>
	CachedHTTPMethods *string

	// 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.  <p>The value specified applies only when the origin
	// adds HTTP headers such as <code>Cache-Control max-age</code>,
	// <code>Cache-Control s-maxage</code>, and <code>Expires</code> to objects.</p>
	MaximumTTL *int64

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

type Certificate struct {

	// The timestamp when the certificate was revoked. This value is present only when
	// the certificate status is REVOKED.
	RevokedAt *time.Time

	// 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 validation status of the certificate.
	Status CertificateStatus

	// 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 created.
	CreatedAt *time.Time

	// 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 domain name of the certificate.
	DomainName *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 renewal eligibility of the certificate.
	EligibleToRenew *string

	// An object that describes the status of the certificate renewal managed by
	// Lightsail.
	RenewalSummary *RenewalSummary

	// The validation failure reason, if any, of the certificate.  <p>The following
	// failure reasons are possible:</p> <ul> <li> <p> <b>
	// <code>NO_AVAILABLE_CONTACTS</code> </b> - This failure applies to email
	// validation, which is not available for Lightsail certificates.</p> </li> <li>
	// <p> <b> <code>ADDITIONAL_VERIFICATION_REQUIRED</code> </b> - 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 <a
	// href="https://console.aws.amazon.com/support/home">AWS Support Center</a> to
	// contact AWS Support.</p> <note> <p>You cannot request a certificate for
	// Amazon-owned domain names such as those ending in amazonaws.com, cloudfront.net,
	// or elasticbeanstalk.com.</p> </note> </li> <li> <p> <b>
	// <code>DOMAIN_NOT_ALLOWED</code> </b> - One or more of the domain names in the
	// certificate request was reported as an unsafe domain by <a
	// href="https://www.virustotal.com/gui/home/url">VirusTotal</a>. To correct the
	// problem, search for your domain name on the <a
	// href="https://www.virustotal.com/gui/home/url">VirusTotal</a> website. If your
	// domain is reported as suspicious, see <a
	// href="https://www.google.com/webmasters/hacked/?hl=en">Google Help for Hacked
	// Websites</a> to learn what you can do.</p> <p>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.</p> <p>If
	// you see this error and your domain is not included in the VirusTotal list, visit
	// the <a href="https://console.aws.amazon.com/support/home">AWS Support Center</a>
	// and create a case.</p> </li> <li> <p> <b> <code>INVALID_PUBLIC_DOMAIN</code>
	// </b> - 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 <code>example.invalidpublicdomain</code> because
	// <code>invalidpublicdomain</code> is not a valid top-level domain.</p> </li> <li>
	// <p> <b> <code>OTHER</code> </b> - 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. </p> </li> </ul>
	RequestFailureReason *string

	// The name of the certificate (e.g., my-certificate).
	Name *string

	// The algorithm used to generate the key pair (the public and private key) of the
	// certificate.
	KeyAlgorithm *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 Amazon Resource Name (ARN) of the certificate.
	Arn *string

	// The timestamp when the certificate is first valid.
	NotBefore *time.Time

	// An array of objects that describe the domain validation records of the
	// certificate.
	DomainValidationRecords []*DomainValidationRecord

	// The certificate authority that issued the certificate.
	IssuerCA *string

	// The serial number of the certificate.
	SerialNumber *string

	// The timestamp when the certificate expires.
	NotAfter *time.Time
}

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

type CertificateSummary struct {

	// 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

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

type CloudFormationStackRecord struct {

	// The Lightsail resource type (e.g., CloudFormationStackRecord).
	ResourceType ResourceType

	// A list of objects describing the Availability Zone and AWS Region of the
	// CloudFormation stack record.
	Location *ResourceLocation

	// 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

	// The current state of the CloudFormation stack record.
	State RecordState

	// The Amazon Resource Name (ARN) of the CloudFormation stack record.
	Arn *string

	// A list of objects describing the source of the CloudFormation stack record.
	SourceInfo []*CloudFormationStackRecordSourceInfo

	// The name of the CloudFormation stack record. It starts with
	// CloudFormationStackRecord followed by a GUID.
	Name *string
}

type CloudFormationStackRecordSourceInfo struct {

	// The Lightsail resource type (e.g., ExportSnapshotRecord).
	ResourceType CloudFormationStackRecordSourceType

	// The name of the record.
	Name *string

	// The Amazon Resource Name (ARN) of the export snapshot record.
	Arn *string
}

type CloudFormationStackRecordSourceType string

const (
	CloudFormationStackRecordSourceTypeExportsnapshotrecord CloudFormationStackRecordSourceType = "ExportSnapshotRecord"
)

type ComparisonOperator string

const (
	ComparisonOperatorGreaterthanorequaltothreshold ComparisonOperator = "GreaterThanOrEqualToThreshold"
	ComparisonOperatorGreaterthanthreshold          ComparisonOperator = "GreaterThanThreshold"
	ComparisonOperatorLessthanthreshold             ComparisonOperator = "LessThanThreshold"
	ComparisonOperatorLessthanorequaltothreshold    ComparisonOperator = "LessThanOrEqualToThreshold"
)

type ContactMethod struct {

	// The Amazon Resource Name (ARN) of the contact method.
	Arn *string

	// The protocol of the contact method, such as email or SMS (text messaging).
	Protocol ContactProtocol

	// 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

	// The timestamp when the contact method was created.
	CreatedAt *time.Time

	// The destination of the contact method, such as an email address or a mobile
	// phone number.
	ContactEndpoint *string

	// 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

	// Describes the resource location.
	Location *ResourceLocation

	// The Lightsail resource type (e.g., ContactMethod).
	ResourceType ResourceType

	// The name of the contact method.
	Name *string
}

type ContactMethodStatus string

const (
	ContactMethodStatusPendingverification ContactMethodStatus = "PendingVerification"
	ContactMethodStatusValid               ContactMethodStatus = "Valid"
	ContactMethodStatusInvalid             ContactMethodStatus = "Invalid"
)

type ContactMethodVerificationProtocol string

const (
	ContactMethodVerificationProtocolEmail ContactMethodVerificationProtocol = "Email"
)

type ContactProtocol string

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

type CookieObject struct {

	// 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

	// The specific cookies to forward to your distribution's origin.
	CookiesAllowList []*string
}

type DestinationInfo struct {

	// The destination service of the record.
	Service *string

	// The ID of the resource created at the destination.
	Id *string
}

type Disk struct {

	// (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.
	AttachmentState *string

	// (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.
	GbInUse *int32

	// The date when the disk was created.
	CreatedAt *time.Time

	// The input/output operations per second (IOPS) of the disk.
	Iops *int32

	// The disk path.
	Path *string

	// The resources to which the disk is attached.
	AttachedTo *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 status of the disk.
	State DiskState

	// The AWS Region and Availability Zone where the disk is located.
	Location *ResourceLocation

	// A Boolean value indicating whether this disk is a system disk (has an operating
	// system loaded on it).
	IsSystemDisk *bool

	// The size of the disk in GB.
	SizeInGb *int32

	// An array of objects representing the add-ons enabled on the disk.
	AddOns []*AddOn

	// 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 Amazon Resource Name (ARN) of the disk.
	Arn *string

	// The Lightsail resource type (e.g., Disk).
	ResourceType ResourceType

	// The unique name of the disk.
	Name *string

	// A Boolean value indicating whether the disk is attached.
	IsAttached *bool
}

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

	// The disk name.
	Name *string

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

type DiskMap struct {

	// The original disk path exposed to the instance (for example, /dev/sdh).
	OriginalDiskPath *string

	// The new disk name (e.g., my-new-disk).
	NewDiskName *string
}

type DiskSnapshot struct {

	// 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 AWS Region and Availability Zone where the disk snapshot was created.
	Location *ResourceLocation

	// The status of the disk snapshot operation.
	State DiskSnapshotState

	// The Lightsail resource type (e.g., DiskSnapshot).
	ResourceType ResourceType

	// The unique name of the source instance from which the disk (system volume)
	// snapshot was created.
	FromInstanceName *string

	// The progress of the disk snapshot operation.
	Progress *string

	// The Amazon Resource Name (ARN) of the source instance from which the disk
	// (system volume) snapshot was created.
	FromInstanceArn *string

	// The name of the disk snapshot (e.g., my-disk-snapshot).
	Name *string

	// The Amazon Resource Name (ARN) of the disk snapshot.
	Arn *string

	// A Boolean value indicating whether the snapshot was created from an automatic
	// snapshot.
	IsFromAutoSnapshot *bool

	// The date when the disk snapshot was created.
	CreatedAt *time.Time

	// The size of the disk in GB.
	SizeInGb *int32

	// The Amazon Resource Name (ARN) of the source disk from which the disk snapshot
	// was created.
	FromDiskArn *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 unique name of the source disk from which the disk snapshot was created.
	FromDiskName *string
}

type DiskSnapshotInfo struct {

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

type DiskSnapshotState string

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

type DiskState string

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

type DistributionBundle struct {

	// The name of the distribution bundle.
	Name *string

	// The ID of the bundle.
	BundleId *string

	// The monthly network transfer quota of the bundle.
	TransferPerMonthInGb *int32

	// Indicates whether the bundle is active, and can be specified for a new
	// distribution.
	IsActive *bool

	// The monthly price, in US dollars, of the bundle.
	Price *float32
}

type DistributionMetricName string

const (
	DistributionMetricNameRequests         DistributionMetricName = "Requests"
	DistributionMetricNameBytesdownloaded  DistributionMetricName = "BytesDownloaded"
	DistributionMetricNameBytesuploaded    DistributionMetricName = "BytesUploaded"
	DistributionMetricNameTotalerrorrate   DistributionMetricName = "TotalErrorRate"
	DistributionMetricNameHttp4xxerrorrate DistributionMetricName = "Http4xxErrorRate"
	DistributionMetricNameHttp5xxerrorrate DistributionMetricName = "Http5xxErrorRate"
)

type Domain struct {

	// The AWS Region and Availability Zones where the domain recordset was created.
	Location *ResourceLocation

	// An array of key-value pairs containing information about the domain entries.
	DomainEntries []*DomainEntry

	// The date when the domain recordset was created.
	CreatedAt *time.Time

	// 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 name of the domain.
	Name *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 Amazon Resource Name (ARN) of the domain recordset (e.g.,
	// arn:aws:lightsail:global:123456789101:Domain/824cede0-abc7-4f84-8dbc-12345EXAMPLE).
	Arn *string
}

type DomainEntry struct {

	// 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 ID of the domain recordset entry.
	Id *string

	// 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.
	Options map[string]*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 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
}

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
}

type ExportSnapshotRecord struct {

	// The Amazon Resource Name (ARN) of the export snapshot record.
	Arn *string

	// A list of objects describing the source of the export snapshot record.
	SourceInfo *ExportSnapshotRecordSourceInfo

	// The state of the export snapshot record.
	State RecordState

	// A list of objects describing the destination of the export snapshot record.
	DestinationInfo *DestinationInfo

	// The date when the export snapshot record was created.
	CreatedAt *time.Time

	// The Lightsail resource type (e.g., ExportSnapshotRecord).
	ResourceType ResourceType

	// The AWS Region and Availability Zone where the export snapshot record is
	// located.
	Location *ResourceLocation

	// The export snapshot record name.
	Name *string
}

type ExportSnapshotRecordSourceInfo struct {

	// A list of objects describing an instance snapshot.
	InstanceSnapshotInfo *InstanceSnapshotInfo

	// The Amazon Resource Name (ARN) of the source instance or disk snapshot.
	Arn *string

	// The name of the snapshot's source instance or disk.
	FromResourceName *string

	// The Amazon Resource Name (ARN) of the snapshot's source instance or disk.
	FromResourceArn *string

	// The date when the source instance or disk snapshot was created.
	CreatedAt *time.Time

	// The name of the source instance or disk snapshot.
	Name *string

	// A list of objects describing a disk snapshot.
	DiskSnapshotInfo *DiskSnapshotInfo

	// The Lightsail resource type (e.g., InstanceSnapshot or DiskSnapshot).
	ResourceType ExportSnapshotRecordSourceType
}

type ExportSnapshotRecordSourceType string

const (
	ExportSnapshotRecordSourceTypeInstancesnapshot ExportSnapshotRecordSourceType = "InstanceSnapshot"
	ExportSnapshotRecordSourceTypeDisksnapshot     ExportSnapshotRecordSourceType = "DiskSnapshot"
)

type ForwardValues string

const (
	ForwardValuesNone      ForwardValues = "none"
	ForwardValuesAllowlist ForwardValues = "allow-list"
	ForwardValuesAll       ForwardValues = "all"
)

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

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.  <p>You can configure your distribution to do one of the
	// following:</p> <ul> <li> <p> <b> <code>all</code> </b> - Forward all headers to
	// your origin.</p> </li> <li> <p> <b> <code>none</code> </b> - Forward only the
	// default headers.</p> </li> <li> <p> <b> <code>allow-list</code> </b> - Forward
	// only the headers you specify using the <code>headersAllowList</code>
	// parameter.</p> </li> </ul>
	Option ForwardValues
}

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 returned RDP certificate is not valid after this point in time. This value
	// is listed only for RDP certificates.
	NotValidAfter *time.Time

	// The public SSH host key or the RDP certificate.
	PublicKey *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 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 returned RDP certificate is valid after this point in time. This value is
	// listed only for RDP certificates.
	NotValidBefore *time.Time

	// The time that the SSH host key or RDP certificate was recorded by Lightsail.
	WitnessedAt *time.Time
}

type InputOrigin struct {

	// The AWS Region name of the origin resource.
	RegionName RegionName

	// The protocol that your Amazon Lightsail distribution uses when establishing a
	// connection with your origin to pull content.
	ProtocolPolicy OriginProtocolPolicyEnum

	// The name of the origin resource.
	Name *string
}

type Instance struct {

	// A Boolean value indicating whether this instance has a static IP assigned to it.
	IsStaticIp *bool

	// Information about the public ports and monthly data transfer rates for the
	// instance.
	Networking *InstanceNetworking

	// The timestamp when the instance was created (e.g., 1479734909.17) in Unix time
	// format.
	CreatedAt *time.Time

	// 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 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 user name for connecting to the instance (e.g., ec2-user).
	Username *string

	// The size of the vCPU and the amount of RAM for the instance.
	Hardware *InstanceHardware

	// The name the user gave the instance (e.g., Amazon_Linux-1GB-Ohio-1).
	Name *string

	// The type of resource (usually Instance).
	ResourceType ResourceType

	// The IPv6 address of the instance.
	Ipv6Address *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 private IP address of the instance.
	PrivateIpAddress *string

	// The status code and the state (e.g., running) for the instance.
	State *InstanceState

	// The region name and Availability Zone where the instance is located.
	Location *ResourceLocation

	// The public IP address of the instance.
	PublicIpAddress *string

	// The friendly name of the blueprint (e.g., Amazon Linux).
	BlueprintName *string

	// An array of objects representing the add-ons enabled on the instance.
	AddOns []*AddOn

	// The bundle for the instance (e.g., micro_1_0).
	BundleId *string

	// The name of the SSH key being used to connect to the instance (e.g.,
	// LightsailDefaultKeyPair).
	SshKeyName *string

	// The blueprint ID (e.g., os_amlinux_2016_03).
	BlueprintId *string
}

type InstanceAccessDetails struct {

	// 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 SSH access, the date on which the temporary keys expire.
	ExpiresAt *time.Time

	// The public IP address of the Amazon Lightsail instance.
	IpAddress *string

	// The protocol for these Amazon Lightsail instance access details.
	Protocol InstanceAccessProtocol

	// Describes the public SSH host keys or the RDP certificate.
	HostKeys []*HostKeyAttributes

	// The name of this Amazon Lightsail instance.
	InstanceName *string

	// The user name to use when logging in to the Amazon Lightsail instance.
	Username *string

	// For SSH access, the temporary private key. For OpenSSH clients (e.g., command
	// line SSH), you should save this value to tempkey).
	PrivateKey *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 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
}

type InstanceAccessProtocol string

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

type InstanceEntry struct {

	// 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

	// 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

	// 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

	// The Availability Zone for the new Amazon EC2 instance.
	//
	// This member is required.
	AvailabilityZone *string
}

type InstanceHardware struct {

	// The disks attached to the instance.
	Disks []*Disk

	// The number of vCPUs the instance has.
	CpuCount *int32

	// The amount of RAM in GB on the instance (e.g., 1.0).
	RamSizeInGb *float32
}

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

type InstanceHealthState string

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

type InstanceHealthSummary struct {

	// The name of the Lightsail instance for which you are requesting health check
	// data.
	InstanceName *string

	// 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

	// Describes the overall instance health. Valid values are below.
	InstanceHealth InstanceHealthState
}

type InstanceMetricName string

const (
	InstanceMetricNameCpuutilization             InstanceMetricName = "CPUUtilization"
	InstanceMetricNameNetworkin                  InstanceMetricName = "NetworkIn"
	InstanceMetricNameNetworkout                 InstanceMetricName = "NetworkOut"
	InstanceMetricNameStatuscheckfailed          InstanceMetricName = "StatusCheckFailed"
	InstanceMetricNameStatuscheckfailed_instance InstanceMetricName = "StatusCheckFailed_Instance"
	InstanceMetricNameStatuscheckfailed_system   InstanceMetricName = "StatusCheckFailed_System"
	InstanceMetricNameBurstcapacitytime          InstanceMetricName = "BurstCapacityTime"
	InstanceMetricNameBurstcapacitypercentage    InstanceMetricName = "BurstCapacityPercentage"
)

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
}

type InstancePlatform string

const (
	InstancePlatformLinuxunix InstancePlatform = "LINUX_UNIX"
	InstancePlatformWindows   InstancePlatform = "WINDOWS"
)

type InstancePortInfo 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 access direction (inbound or outbound). Lightsail currently supports only
	// inbound access direction.
	AccessDirection AccessDirection

	// The type of access (Public or Private).
	AccessType PortAccessType

	// The common name of the port information.
	CommonName *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 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

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

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

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

type InstanceSnapshot struct {

	// The size in GB of the SSD.
	SizeInGb *int32

	// The state the snapshot is in.
	State InstanceSnapshotState

	// The timestamp when the snapshot was created (e.g., 1479907467.024).
	CreatedAt *time.Time

	// The region name and Availability Zone where you created the snapshot.
	Location *ResourceLocation

	// The type of resource (usually InstanceSnapshot).
	ResourceType ResourceType

	// A Boolean value indicating whether the snapshot was created from an automatic
	// snapshot.
	IsFromAutoSnapshot *bool

	// The progress of the snapshot.
	Progress *string

	// The instance from which the snapshot was created.
	FromInstanceName *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 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 name of the snapshot.
	Name *string

	// 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 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 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

	// An array of disk objects containing information about all block storage disks.
	FromAttachedDisks []*Disk

	// The bundle ID from which you created the snapshot (e.g., micro_1_0).
	FromBundleId *string
}

type InstanceSnapshotInfo struct {

	// The blueprint ID from which the source instance (e.g., os_debian_8_3).
	FromBlueprintId *string

	// A list of objects describing the disks that were attached to the source
	// instance.
	FromDiskInfo []*DiskInfo

	// The bundle ID from which the source instance was created (e.g., micro_1_0).
	FromBundleId *string
}

type InstanceSnapshotState string

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

type InstanceState struct {

	// The state of the instance (e.g., running or pending).
	Name *string

	// The status code for the instance.
	Code *int32
}

type InvalidInputException struct {
	Message *string

	Tip  *string
	Code *string
	Docs *string
}

type KeyPair struct {

	// The friendly name of the SSH key pair.
	Name *string

	// The RSA fingerprint of the key pair.
	Fingerprint *string

	// 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 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 resource type (usually KeyPair).
	ResourceType ResourceType

	// The region name and Availability Zone where the key pair was created.
	Location *ResourceLocation

	// The timestamp when the key pair was created (e.g., 1479816991.349).
	CreatedAt *time.Time
}

type LightsailDistribution struct {

	// An array of objects that describe the per-path cache behavior of the
	// distribution.
	CacheBehaviors []*CacheBehaviorPerPath

	// 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 status of the distribution.
	Status *string

	// An object that describes the origin resource of the distribution, such as a
	// Lightsail instance or load balancer.  <p>The distribution pulls, caches, and
	// serves content from the origin.</p>
	Origin *Origin

	// An object that describes the cache behavior settings of the distribution.
	CacheBehaviorSettings *CacheSettings

	// The public DNS of the origin.
	OriginPublicDNS *string

	// The Lightsail resource type (e.g., Distribution).
	ResourceType ResourceType

	// An object that describes the default cache behavior of the distribution.
	DefaultCacheBehavior *CacheBehavior

	// The timestamp when the distribution was created.
	CreatedAt *time.Time

	// The Amazon Resource Name (ARN) of the distribution.
	Arn *string

	// Indicates whether the distribution is enabled.
	IsEnabled *bool

	// The name of the SSL/TLS certificate attached to the distribution, if any.
	CertificateName *string

	// The domain name of the distribution.
	DomainName *string

	// Indicates whether the bundle that is currently applied to your distribution,
	// specified using the distributionName parameter, can be changed to another
	// bundle.  <p>Use the <code>UpdateDistributionBundle</code> action to change your
	// distribution's bundle.</p>
	AbleToUpdateBundle *bool

	// The name of the distribution.
	Name *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 alternate domain names of the distribution.
	AlternativeDomainNames []*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 ID of the bundle currently applied to the distribution.
	BundleId *string
}

type LoadBalancer struct {

	// 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

	// The date when your load balancer was created.
	CreatedAt *time.Time

	// 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

	// 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 InstanceHealthSummary objects describing the health of the load
	// balancer.
	InstanceHealthSummary []*InstanceHealthSummary

	// The resource type (e.g., LoadBalancer.
	ResourceType ResourceType

	// The name of the load balancer (e.g., my-load-balancer).
	Name *string

	// 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 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 Amazon Resource Name (ARN) of the load balancer.
	Arn *string

	// The DNS name of your Lightsail load balancer.
	DnsName *string

	// An array of public port settings for your load balancer. For HTTP, use port 80.
	// For HTTPS, use port 443.
	PublicPorts []*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 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

	// A string to string map of the configuration options for your load balancer.
	// Valid values are listed below.
	ConfigurationOptions map[string]*string
}

type LoadBalancerAttributeName string

const (
	LoadBalancerAttributeNameHealthcheckpath                            LoadBalancerAttributeName = "HealthCheckPath"
	LoadBalancerAttributeNameSessionstickinessenabled                   LoadBalancerAttributeName = "SessionStickinessEnabled"
	LoadBalancerAttributeNameSessionstickiness_lb_cookiedurationseconds LoadBalancerAttributeName = "SessionStickiness_LB_CookieDurationSeconds"
)

type LoadBalancerMetricName string

const (
	LoadBalancerMetricNameClienttlsnegotiationerrorcount LoadBalancerMetricName = "ClientTLSNegotiationErrorCount"
	LoadBalancerMetricNameHealthyhostcount               LoadBalancerMetricName = "HealthyHostCount"
	LoadBalancerMetricNameUnhealthyhostcount             LoadBalancerMetricName = "UnhealthyHostCount"
	LoadBalancerMetricNameHttpcode_lb_4xx_count          LoadBalancerMetricName = "HTTPCode_LB_4XX_Count"
	LoadBalancerMetricNameHttpcode_lb_5xx_count          LoadBalancerMetricName = "HTTPCode_LB_5XX_Count"
	LoadBalancerMetricNameHttpcode_instance_2xx_count    LoadBalancerMetricName = "HTTPCode_Instance_2XX_Count"
	LoadBalancerMetricNameHttpcode_instance_3xx_count    LoadBalancerMetricName = "HTTPCode_Instance_3XX_Count"
	LoadBalancerMetricNameHttpcode_instance_4xx_count    LoadBalancerMetricName = "HTTPCode_Instance_4XX_Count"
	LoadBalancerMetricNameHttpcode_instance_5xx_count    LoadBalancerMetricName = "HTTPCode_Instance_5XX_Count"
	LoadBalancerMetricNameInstanceresponsetime           LoadBalancerMetricName = "InstanceResponseTime"
	LoadBalancerMetricNameRejectedconnectioncount        LoadBalancerMetricName = "RejectedConnectionCount"
	LoadBalancerMetricNameRequestcount                   LoadBalancerMetricName = "RequestCount"
)

type LoadBalancerProtocol string

const (
	LoadBalancerProtocolHttp_https LoadBalancerProtocol = "HTTP_HTTPS"
	LoadBalancerProtocolHttp       LoadBalancerProtocol = "HTTP"
)

type LoadBalancerState string

const (
	LoadBalancerStateActive         LoadBalancerState = "active"
	LoadBalancerStateProvisioning   LoadBalancerState = "provisioning"
	LoadBalancerStateActiveimpaired LoadBalancerState = "active_impaired"
	LoadBalancerStateFailed         LoadBalancerState = "failed"
	LoadBalancerStateUnknown        LoadBalancerState = "unknown"
)

type LoadBalancerTlsCertificate struct {

	// The issuer of the certificate.
	Issuer *string

	// The name of the entity that is associated with the public key contained in the
	// certificate.
	Subject *string

	// The reason the certificate was revoked. This value is present only when the
	// certificate status is REVOKED.
	RevocationReason LoadBalancerTlsCertificateRevocationReason

	// The timestamp when the SSL/TLS certificate expires.
	NotAfter *time.Time

	// 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 algorithm used to generate the key pair (the public and private key).
	KeyAlgorithm *string

	// The timestamp when the SSL/TLS certificate is first valid.
	NotBefore *time.Time

	// An array of LoadBalancerTlsCertificateDomainValidationRecord objects describing
	// the records.
	DomainValidationRecords []*LoadBalancerTlsCertificateDomainValidationRecord

	// The load balancer name where your SSL/TLS certificate is attached.
	LoadBalancerName *string

	// The time when you created your SSL/TLS certificate.
	CreatedAt *time.Time

	// An object that describes the status of the certificate renewal managed by
	// Lightsail.
	RenewalSummary *LoadBalancerTlsCertificateRenewalSummary

	// The time when the SSL/TLS certificate was issued.
	IssuedAt *time.Time

	// The Amazon Resource Name (ARN) of the SSL/TLS certificate.
	Arn *string

	// The timestamp when the certificate was revoked. This value is present only when
	// the certificate status is REVOKED.
	RevokedAt *time.Time

	// 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 AWS Region and Availability Zone where you created your certificate.
	Location *ResourceLocation

	// The algorithm that was used to sign the certificate.
	SignatureAlgorithm *string

	// 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 validation failure reason, if any, of the certificate.  <p>The following
	// failure reasons are possible:</p> <ul> <li> <p> <b>
	// <code>NO_AVAILABLE_CONTACTS</code> </b> - This failure applies to email
	// validation, which is not available for Lightsail certificates.</p> </li> <li>
	// <p> <b> <code>ADDITIONAL_VERIFICATION_REQUIRED</code> </b> - 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 <a
	// href="https://console.aws.amazon.com/support/home">AWS Support Center</a> to
	// contact AWS Support.</p> <note> <p>You cannot request a certificate for
	// Amazon-owned domain names such as those ending in amazonaws.com, cloudfront.net,
	// or elasticbeanstalk.com.</p> </note> </li> <li> <p> <b>
	// <code>DOMAIN_NOT_ALLOWED</code> </b> - One or more of the domain names in the
	// certificate request was reported as an unsafe domain by <a
	// href="https://www.virustotal.com/gui/home/url">VirusTotal</a>. To correct the
	// problem, search for your domain name on the <a
	// href="https://www.virustotal.com/gui/home/url">VirusTotal</a> website. If your
	// domain is reported as suspicious, see <a
	// href="https://www.google.com/webmasters/hacked/?hl=en">Google Help for Hacked
	// Websites</a> to learn what you can do.</p> <p>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.</p> <p>If
	// you see this error and your domain is not included in the VirusTotal list, visit
	// the <a href="https://console.aws.amazon.com/support/home">AWS Support Center</a>
	// and create a case.</p> </li> <li> <p> <b> <code>INVALID_PUBLIC_DOMAIN</code>
	// </b> - 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 <code>example.invalidpublicdomain</code> because
	// <code>invalidpublicdomain</code> is not a valid top-level domain.</p> </li> <li>
	// <p> <b> <code>OTHER</code> </b> - 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. </p> </li> </ul>
	FailureReason LoadBalancerTlsCertificateFailureReason

	// The domain name for your SSL/TLS certificate.
	DomainName *string

	// The serial number of the certificate.
	Serial *string

	// When true, the SSL/TLS certificate is attached to the Lightsail load balancer.
	IsAttached *bool

	// The validation status of the SSL/TLS certificate. Valid values are below.
	Status LoadBalancerTlsCertificateStatus

	// 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 name of the SSL/TLS certificate (e.g., my-certificate).
	Name *string
}

type LoadBalancerTlsCertificateDomainStatus string

const (
	LoadBalancerTlsCertificateDomainStatusPendingvalidation LoadBalancerTlsCertificateDomainStatus = "PENDING_VALIDATION"
	LoadBalancerTlsCertificateDomainStatusFailed            LoadBalancerTlsCertificateDomainStatus = "FAILED"
	LoadBalancerTlsCertificateDomainStatusSuccess           LoadBalancerTlsCertificateDomainStatus = "SUCCESS"
)

type LoadBalancerTlsCertificateDomainValidationOption struct {

	// The status of the domain validation. Valid values are listed below.
	ValidationStatus LoadBalancerTlsCertificateDomainStatus

	// The fully qualified domain name in the certificate request.
	DomainName *string
}

type LoadBalancerTlsCertificateDomainValidationRecord struct {

	// The value for that type.
	Value *string

	// A fully qualified domain name in the certificate. For example, example.com.
	Name *string

	// The domain name against which your SSL/TLS certificate was validated.
	DomainName *string

	// The type of validation record. For example, CNAME for domain validation.
	Type *string

	// The validation status. Valid values are listed below.
	ValidationStatus LoadBalancerTlsCertificateDomainStatus
}

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

type LoadBalancerTlsCertificateRenewalStatus string

const (
	LoadBalancerTlsCertificateRenewalStatusPendingautorenewal LoadBalancerTlsCertificateRenewalStatus = "PENDING_AUTO_RENEWAL"
	LoadBalancerTlsCertificateRenewalStatusPendingvalidation  LoadBalancerTlsCertificateRenewalStatus = "PENDING_VALIDATION"
	LoadBalancerTlsCertificateRenewalStatusSuccess            LoadBalancerTlsCertificateRenewalStatus = "SUCCESS"
	LoadBalancerTlsCertificateRenewalStatusFailed             LoadBalancerTlsCertificateRenewalStatus = "FAILED"
)

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
}

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

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

type LoadBalancerTlsCertificateSummary struct {

	// The name of the SSL/TLS certificate.
	Name *string

	// When true, the SSL/TLS certificate is attached to the Lightsail load balancer.
	IsAttached *bool
}

type LogEvent struct {

	// The timestamp when the database log event was created.
	CreatedAt *time.Time

	// The message of the database log event.
	Message *string
}

type MetricDatapoint struct {

	// The maximum.
	Maximum *float64

	// The sample count.
	SampleCount *float64

	// The timestamp (e.g., 1479816991.349).
	Timestamp *time.Time

	// The unit.
	Unit MetricUnit

	// The average.
	Average *float64

	// The minimum.
	Minimum *float64

	// The sum.
	Sum *float64
}

type MetricName string

const (
	MetricNameCpuutilization                 MetricName = "CPUUtilization"
	MetricNameNetworkin                      MetricName = "NetworkIn"
	MetricNameNetworkout                     MetricName = "NetworkOut"
	MetricNameStatuscheckfailed              MetricName = "StatusCheckFailed"
	MetricNameStatuscheckfailed_instance     MetricName = "StatusCheckFailed_Instance"
	MetricNameStatuscheckfailed_system       MetricName = "StatusCheckFailed_System"
	MetricNameClienttlsnegotiationerrorcount MetricName = "ClientTLSNegotiationErrorCount"
	MetricNameHealthyhostcount               MetricName = "HealthyHostCount"
	MetricNameUnhealthyhostcount             MetricName = "UnhealthyHostCount"
	MetricNameHttpcode_lb_4xx_count          MetricName = "HTTPCode_LB_4XX_Count"
	MetricNameHttpcode_lb_5xx_count          MetricName = "HTTPCode_LB_5XX_Count"
	MetricNameHttpcode_instance_2xx_count    MetricName = "HTTPCode_Instance_2XX_Count"
	MetricNameHttpcode_instance_3xx_count    MetricName = "HTTPCode_Instance_3XX_Count"
	MetricNameHttpcode_instance_4xx_count    MetricName = "HTTPCode_Instance_4XX_Count"
	MetricNameHttpcode_instance_5xx_count    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"
)

type MetricStatistic string

const (
	MetricStatisticMinimum     MetricStatistic = "Minimum"
	MetricStatisticMaximum     MetricStatistic = "Maximum"
	MetricStatisticSum         MetricStatistic = "Sum"
	MetricStatisticAverage     MetricStatistic = "Average"
	MetricStatisticSamplecount MetricStatistic = "SampleCount"
)

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

type MonitoredResourceInfo struct {

	// The name of the Lightsail resource being monitored.
	Name *string

	// The Amazon Resource Name (ARN) of the resource being monitored.
	Arn *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
}

type MonthlyTransfer struct {

	// The amount allocated per month (in GB).
	GbPerMonthAllocated *int32
}

type NetworkProtocol string

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

type NotFoundException struct {
	Message *string

	Tip  *string
	Docs *string
	Code *string
}

type Operation struct {

	// The timestamp when the status was changed (e.g., 1479816991.349).
	StatusChangedAt *time.Time

	// The resource type.
	ResourceType ResourceType

	// The ID of the operation.
	Id *string

	// The AWS Region and Availability Zone.
	Location *ResourceLocation

	// A Boolean value indicating whether the operation is terminal.
	IsTerminal *bool

	// Details about the operation (e.g., Debian-1GB-Ohio-1).
	OperationDetails *string

	// The type of operation.
	OperationType OperationType

	// The resource name.
	ResourceName *string

	// The status of the operation.
	Status OperationStatus

	// The error details.
	ErrorDetails *string

	// The timestamp when the operation was initialized (e.g., 1479816991.349).
	CreatedAt *time.Time

	// The error code.
	ErrorCode *string
}

type OperationFailureException struct {
	Message *string

	Code *string
	Tip  *string
	Docs *string
}

type OperationStatus string

const (
	OperationStatusNotstarted OperationStatus = "NotStarted"
	OperationStatusStarted    OperationStatus = "Started"
	OperationStatusFailed     OperationStatus = "Failed"
	OperationStatusCompleted  OperationStatus = "Completed"
	OperationStatusSucceeded  OperationStatus = "Succeeded"
)

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

type Origin struct {

	// The AWS Region name of the origin resource.
	RegionName RegionName

	// The protocol that your Amazon Lightsail distribution uses when establishing a
	// connection with your origin to pull content.
	ProtocolPolicy OriginProtocolPolicyEnum

	// The name of the origin resource.
	Name *string

	// The resource type of the origin resource (e.g., Instance).
	ResourceType ResourceType
}

type OriginProtocolPolicyEnum string

const (
	OriginProtocolPolicyEnumHttponly  OriginProtocolPolicyEnum = "http-only"
	OriginProtocolPolicyEnumHttpsonly OriginProtocolPolicyEnum = "https-only"
)

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
}

type PendingMaintenanceAction struct {

	// The effective date of the pending database maintenance action.
	CurrentApplyDate *time.Time

	// The type of pending database maintenance action.
	Action *string

	// Additional detail about the pending database maintenance action.
	Description *string
}

type PendingModifiedRelationalDatabaseValues struct {

	// The database engine version.
	EngineVersion *string

	// A Boolean value indicating whether automated backup retention is enabled.
	BackupRetentionEnabled *bool

	// The password for the master user of the database.
	MasterUserPassword *string
}

type PortAccessType string

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

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

type PortInfoSourceType string

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

type PortState string

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

type QueryStringObject struct {

	// The specific query strings that the distribution forwards to the origin.
	// <p>Your distribution will cache content based on the specified query
	// strings.</p> <p>If the <code>option</code> parameter is true, then your
	// distribution forwards all query strings, regardless of what you specify using
	// the <code>queryStringsAllowList</code> parameter.</p>
	QueryStringsAllowList []*string

	// Indicates whether the distribution forwards and caches based on query strings.
	Option *bool
}

type RecordState string

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

type Region struct {

	// The continent code (e.g., NA, meaning North America).
	ContinentCode *string

	// The display name (e.g., Ohio).
	DisplayName *string

	// The Availability Zones for databases. Follows the format us-east-2a
	// (case-sensitive).
	RelationalDatabaseAvailabilityZones []*AvailabilityZone

	// The region name (e.g., us-east-2).
	Name RegionName

	// 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 Availability Zones. Follows the format us-east-2a (case-sensitive).
	AvailabilityZones []*AvailabilityZone
}

type RegionName string

const (
	RegionNameUs_east_1      RegionName = "us-east-1"
	RegionNameUs_east_2      RegionName = "us-east-2"
	RegionNameUs_west_1      RegionName = "us-west-1"
	RegionNameUs_west_2      RegionName = "us-west-2"
	RegionNameEu_west_1      RegionName = "eu-west-1"
	RegionNameEu_west_2      RegionName = "eu-west-2"
	RegionNameEu_west_3      RegionName = "eu-west-3"
	RegionNameEu_central_1   RegionName = "eu-central-1"
	RegionNameCa_central_1   RegionName = "ca-central-1"
	RegionNameAp_south_1     RegionName = "ap-south-1"
	RegionNameAp_southeast_1 RegionName = "ap-southeast-1"
	RegionNameAp_southeast_2 RegionName = "ap-southeast-2"
	RegionNameAp_northeast_1 RegionName = "ap-northeast-1"
	RegionNameAp_northeast_2 RegionName = "ap-northeast-2"
)

type RelationalDatabase struct {

	// The database software (for example, MySQL).
	Engine *string

	// A Boolean value indicating whether automated backup retention is enabled for the
	// database.
	BackupRetentionEnabled *bool

	// 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 database engine version (for example, 5.7.23).
	EngineVersion *string

	// The daily time range during which automated backups are created for the database
	// (for example, 16:00-16:30).
	PreferredBackupWindow *string

	// The master user name of the database.
	MasterUsername *string

	// The Amazon Resource Name (ARN) of the database.
	Arn *string

	// The timestamp when the database was created. Formatted in Unix time.
	CreatedAt *time.Time

	// Describes the pending maintenance actions for the database.
	PendingMaintenanceActions []*PendingMaintenanceAction

	// The name of the master database created when the Lightsail database resource is
	// created.
	MasterDatabaseName *string

	// 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

	// The certificate associated with the database.
	CaCertificateIdentifier *string

	// Describes the hardware of the database.
	Hardware *RelationalDatabaseHardware

	// A Boolean value indicating whether the database is publicly accessible.
	PubliclyAccessible *bool

	// The latest point in time to which the database can be restored. Formatted in
	// Unix time.
	LatestRestorableTime *time.Time

	// The status of parameter updates for the database.
	ParameterApplyStatus *string

	// Describes the current state of the database.
	State *string

	// The blueprint ID for the database. A blueprint describes the major engine
	// version of a database.
	RelationalDatabaseBlueprintId *string

	// Describes pending database value modifications.
	PendingModifiedValues *PendingModifiedRelationalDatabaseValues

	// 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

	// The master endpoint for the database.
	MasterEndpoint *RelationalDatabaseEndpoint

	// The bundle ID for the database. A bundle describes the performance
	// specifications for your database.
	RelationalDatabaseBundleId *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 Lightsail resource type for the database (for example, RelationalDatabase).
	ResourceType ResourceType

	// The Region name and Availability Zone where the database is located.
	Location *ResourceLocation

	// The unique name of the database resource in Lightsail.
	Name *string
}

type RelationalDatabaseBlueprint struct {

	// The database engine version for the database blueprint (for example, 5.7.23).
	EngineVersion *string

	// A Boolean value indicating whether the engine version is the default for the
	// database blueprint.
	IsEngineDefault *bool

	// The description of the database engine version for the database blueprint.
	EngineVersionDescription *string

	// The database software of the database blueprint (for example, MySQL).
	Engine RelationalDatabaseEngine

	// The ID for the database blueprint.
	BlueprintId *string

	// The description of the database engine for the database blueprint.
	EngineDescription *string
}

type RelationalDatabaseBundle struct {

	// The ID for the database bundle.
	BundleId *string

	// The name for the database bundle.
	Name *string

	// A Boolean value indicating whether the database bundle is active.
	IsActive *bool

	// The size of the disk for the database bundle.
	DiskSizeInGb *int32

	// The data transfer rate per month in GB for the database bundle.
	TransferPerMonthInGb *int32

	// A Boolean value indicating whether the database bundle is encrypted.
	IsEncrypted *bool

	// 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 number of virtual CPUs (vCPUs) for the database bundle.
	CpuCount *int32
}

type RelationalDatabaseEndpoint struct {

	// Specifies the port that the database is listening on.
	Port *int32

	// Specifies the DNS address of the database.
	Address *string
}

type RelationalDatabaseEngine string

const (
	RelationalDatabaseEngineMysql RelationalDatabaseEngine = "mysql"
)

type RelationalDatabaseEvent struct {

	// The timestamp when the database event was created.
	CreatedAt *time.Time

	// The database that the database event relates to.
	Resource *string

	// The category that the database event belongs to.
	EventCategories []*string

	// The message of the database event.
	Message *string
}

type RelationalDatabaseHardware struct {

	// The amount of RAM in GB for the database.
	RamSizeInGb *float32

	// The number of vCPUs for the database.
	CpuCount *int32

	// The size of the disk for the database.
	DiskSizeInGb *int32
}

type RelationalDatabaseMetricName string

const (
	RelationalDatabaseMetricNameCpuutilization            RelationalDatabaseMetricName = "CPUUtilization"
	RelationalDatabaseMetricNameDatabaseconnections       RelationalDatabaseMetricName = "DatabaseConnections"
	RelationalDatabaseMetricNameDiskqueuedepth            RelationalDatabaseMetricName = "DiskQueueDepth"
	RelationalDatabaseMetricNameFreestoragespace          RelationalDatabaseMetricName = "FreeStorageSpace"
	RelationalDatabaseMetricNameNetworkreceivethroughput  RelationalDatabaseMetricName = "NetworkReceiveThroughput"
	RelationalDatabaseMetricNameNetworktransmitthroughput RelationalDatabaseMetricName = "NetworkTransmitThroughput"
)

type RelationalDatabaseParameter struct {

	// Specifies the name of the parameter.
	ParameterName *string

	// Provides a description of the parameter.
	Description *string

	// Specifies the valid data type for the parameter.
	DataType *string

	// Indicates when parameter updates are applied. Can be immediate or
	// pending-reboot.
	ApplyMethod *string

	// Specifies the valid range of values for the parameter.
	AllowedValues *string

	// A Boolean value indicating whether the parameter can be modified.
	IsModifiable *bool

	// Specifies the engine-specific parameter type.
	ApplyType *string

	// Specifies the value of the parameter.
	ParameterValue *string
}

type RelationalDatabasePasswordVersion string

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

type RelationalDatabaseSnapshot struct {

	// The size of the disk in GB (for example, 32) for the database snapshot.
	SizeInGb *int32

	// The Region name and Availability Zone where the database snapshot is located.
	Location *ResourceLocation

	// The bundle ID of the database from which the database snapshot was created.
	FromRelationalDatabaseBundleId *string

	// The database engine version for the database snapshot (for example, 5.7.23).
	EngineVersion *string

	// The timestamp when the database snapshot was created.
	CreatedAt *time.Time

	// 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 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 name of the source database from which the database snapshot was created.
	FromRelationalDatabaseName *string

	// The name of the database snapshot.
	Name *string

	// The Lightsail resource type.
	ResourceType ResourceType

	// 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 Amazon Resource Name (ARN) of the database snapshot.
	Arn *string

	// The state of the database snapshot.
	State *string

	// The software of the database snapshot (for example, MySQL)
	Engine *string

	// The Amazon Resource Name (ARN) of the database from which the database snapshot
	// was created.
	FromRelationalDatabaseArn *string
}

type RenewalStatus string

const (
	RenewalStatusPendingautorenewal RenewalStatus = "PendingAutoRenewal"
	RenewalStatusPendingvalidation  RenewalStatus = "PendingValidation"
	RenewalStatusSuccess            RenewalStatus = "Success"
	RenewalStatusFailed             RenewalStatus = "Failed"
)

type RenewalSummary struct {

	// The timestamp when the certificate was last updated.
	UpdatedAt *time.Time

	// An array of objects that describe the domain validation records of the
	// certificate.
	DomainValidationRecords []*DomainValidationRecord

	// The renewal status of the certificate.  <p>The following renewal status are
	// possible:</p> <ul> <li> <p> <b> <code>PendingAutoRenewal</code> </b> - Lightsail
	// is attempting to automatically validate the domain names of the certificate. No
	// further action is required. </p> </li> <li> <p> <b>
	// <code>PendingValidation</code> </b> - 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.</p> </li> <li> <p> <b> <code>Success</code>
	// </b> - All domain names in the certificate are validated, and Lightsail renewed
	// the certificate. No further action is required. </p> </li> <li> <p> <b>
	// <code>Failed</code> </b> - 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 <code>CreateCertificate</code> action.</p>
	// </li> </ul>
	RenewalStatus RenewalStatus

	// The reason for the renewal status of the certificate.
	RenewalStatusReason *string
}

type ResourceLocation struct {

	// The Availability Zone. Follows the format us-east-2a (case-sensitive).
	AvailabilityZone *string

	// The AWS Region name.
	RegionName RegionName
}

type ResourceRecord struct {

	// The name of the record.
	Name *string

	// The value for the DNS record.
	Value *string

	// The DNS record type.
	Type *string
}

type ResourceType string

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

type ServiceException struct {
	Message *string

	Docs *string
	Tip  *string
	Code *string
}

type StaticIp struct {

	// The name of the static IP (e.g., StaticIP-Ohio-EXAMPLE).
	Name *string

	// The static IP address.
	IpAddress *string

	// A Boolean value indicating whether the static IP is attached.
	IsAttached *bool

	// The instance where the static IP is attached (e.g., Amazon_Linux-1GB-Ohio-1).
	AttachedTo *string

	// The region and Availability Zone where the static IP was created.
	Location *ResourceLocation

	// The timestamp when the static IP was created (e.g., 1479735304.222).
	CreatedAt *time.Time

	// 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 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 resource type (usually StaticIp).
	ResourceType ResourceType
}

type Tag struct {

	// 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

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

type TreatMissingData string

const (
	TreatMissingDataBreaching    TreatMissingData = "breaching"
	TreatMissingDataNotbreaching TreatMissingData = "notBreaching"
	TreatMissingDataIgnore       TreatMissingData = "ignore"
	TreatMissingDataMissing      TreatMissingData = "missing"
)

type UnauthenticatedException struct {
	Message *string

	Tip  *string
	Code *string
	Docs *string
}