type AbortAction string

const (
	AbortActionCancel AbortAction = "CANCEL"
)

type AbortConfig struct {
	// The list of criteria that determine when and how to abort the job.
	CriteriaList []*AbortCriteria
}

type AbortCriteria struct {
	// The type of job action to take to initiate the job abort.
	Action AbortAction
	// The minimum number of things which must receive job execution notifications
	// before the job can be aborted.
	MinNumberOfExecutedThings *int32
	// The type of job execution failures that can initiate a job abort.
	FailureType JobExecutionFailureType
	// The minimum percentage of job execution failures that must occur to initiate the
	// job abort. AWS IoT supports up to two digits after the decimal (for example,
	// 10.9 and 10.99, but not 10.999).
	ThresholdPercentage *float64
}

type Action struct {
	// Starts execution of a Step Functions state machine.
	StepFunctions *StepFunctionsAction
	// Write data to an Amazon Kinesis stream.
	Kinesis *KinesisAction
	// Write to an Amazon Kinesis Firehose stream.
	Firehose *FirehoseAction
	// Write to an Amazon S3 bucket.
	S3 *S3Action
	// Write to a DynamoDB table. This is a new version of the DynamoDB action. It
	// allows you to write each attribute in an MQTT message payload into a separate
	// DynamoDB column.
	DynamoDBv2 *DynamoDBv2Action
	// Capture a CloudWatch metric.
	CloudwatchMetric *CloudwatchMetricAction
	// Publish to another MQTT topic.
	Republish *RepublishAction
	// Publish to an Amazon SNS topic.
	Sns *SnsAction
	// Send data to an HTTPS endpoint.
	Http *HttpAction
	// Publish to an Amazon SQS queue.
	Sqs *SqsAction
	// Write data to an Amazon Elasticsearch Service domain.
	Elasticsearch *ElasticsearchAction
	// Invoke a Lambda function.
	Lambda *LambdaAction
	// Change the state of a CloudWatch alarm.
	CloudwatchAlarm *CloudwatchAlarmAction
	// Sends an input to an AWS IoT Events detector.
	IotEvents *IotEventsAction
	// Sends data from the MQTT message that triggered the rule to AWS IoT SiteWise
	// asset properties.
	IotSiteWise *IotSiteWiseAction
	// Send data to CloudWatch Logs.
	CloudwatchLogs *CloudwatchLogsAction
	// Send a message to a Salesforce IoT Cloud Input Stream.
	Salesforce *SalesforceAction
	// Write to a DynamoDB table.
	DynamoDB *DynamoDBAction
	// Sends message data to an AWS IoT Analytics channel.
	IotAnalytics *IotAnalyticsAction
}

type ActionType string

const (
	ActionTypePublish   ActionType = "PUBLISH"
	ActionTypeSubscribe ActionType = "SUBSCRIBE"
	ActionTypeReceive   ActionType = "RECEIVE"
	ActionTypeConnect   ActionType = "CONNECT"
)

type ActiveViolation struct {
	// The name of the thing responsible for the active violation.
	ThingName *string
	// The time the violation started.
	ViolationStartTime *time.Time
	// The behavior which is being violated.
	Behavior *Behavior
	// The ID of the active violation.
	ViolationId *string
	// The security profile whose behavior is in violation.
	SecurityProfileName *string
	// The value of the metric (the measurement) which caused the most recent
	// violation.
	LastViolationValue *MetricValue
	// The time the most recent violation occurred.
	LastViolationTime *time.Time
}

type AddThingsToThingGroupParams struct {
	// Specifies if this mitigation action can move the things that triggered the
	// mitigation action even if they are part of one or more dynamic things groups.
	OverrideDynamicGroups *bool
	// The list of groups to which you want to add the things that triggered the
	// mitigation action. You can add a thing to a maximum of 10 groups, but you cannot
	// add a thing to more than one group in the same hierarchy.
	ThingGroupNames []*string
}

type AlertTarget struct {
	// The ARN of the notification target to which alerts are sent.
	AlertTargetArn *string
	// The ARN of the role that grants permission to send alerts to the notification
	// target.
	RoleArn *string
}

type AlertTargetType string

const (
	AlertTargetTypeSns AlertTargetType = "SNS"
)

type Allowed struct {
	// A list of policies that allowed the authentication.
	Policies []*Policy
}

type AssetPropertyTimestamp struct {
	// A string that contains the time in seconds since epoch. Accepts substitution
	// templates.
	TimeInSeconds *string
	// Optional. A string that contains the nanosecond time offset. Accepts
	// substitution templates.
	OffsetInNanos *string
}

type AssetPropertyValue struct {
	// Optional. A string that describes the quality of the value. Accepts substitution
	// templates. Must be GOOD, BAD, or UNCERTAIN.
	Quality *string
	// The asset property value timestamp.
	Timestamp *AssetPropertyTimestamp
	// The value of the asset property.
	Value *AssetPropertyVariant
}

type AssetPropertyVariant struct {
	// Optional. The string value of the value entry. Accepts substitution templates.
	StringValue *string
	// Optional. A string that contains the integer value of the value entry. Accepts
	// substitution templates.
	IntegerValue *string
	// Optional. A string that contains the double value of the value entry. Accepts
	// substitution templates.
	DoubleValue *string
	// Optional. A string that contains the boolean value (true or false) of the value
	// entry. Accepts substitution templates.
	BooleanValue *string
}

type AttributePayload struct {
	// A JSON string containing up to three key-value pair in JSON format. For example:
	// {\"attributes\":{\"string1\":\"string2\"}}
	Attributes map[string]*string
	// Specifies whether the list of attributes provided in the AttributePayload is
	// merged with the attributes stored in the registry, instead of overwriting them.
	// To remove an attribute, call UpdateThing with an empty attribute value. The
	// merge attribute is only valid when calling UpdateThing or UpdateThingGroup.
	Merge *bool
}

type AuditCheckConfiguration struct {
	// True if this audit check is enabled for this account.
	Enabled *bool
}

type AuditCheckDetails struct {
	// The number of resources that were found noncompliant during the check.
	NonCompliantResourcesCount *int64
	// The message associated with any error encountered when this check is performed
	// during this audit.
	Message *string
	// True if the check is complete and found all resources compliant.
	CheckCompliant *bool
	// The code of any error encountered when this check is performed during this
	// audit. One of "INSUFFICIENT_PERMISSIONS" or "AUDIT_CHECK_DISABLED".
	ErrorCode *string
	// The completion status of this check. One of "IN_PROGRESS",
	// "WAITING_FOR_DATA_COLLECTION", "CANCELED", "COMPLETED_COMPLIANT",
	// "COMPLETED_NON_COMPLIANT", or "FAILED".
	CheckRunStatus AuditCheckRunStatus
	// The number of resources on which the check was performed.
	TotalResourcesCount *int64
}

type AuditCheckRunStatus string

const (
	AuditCheckRunStatusIn_progress                 AuditCheckRunStatus = "IN_PROGRESS"
	AuditCheckRunStatusWaiting_for_data_collection AuditCheckRunStatus = "WAITING_FOR_DATA_COLLECTION"
	AuditCheckRunStatusCanceled                    AuditCheckRunStatus = "CANCELED"
	AuditCheckRunStatusCompleted_compliant         AuditCheckRunStatus = "COMPLETED_COMPLIANT"
	AuditCheckRunStatusCompleted_non_compliant     AuditCheckRunStatus = "COMPLETED_NON_COMPLIANT"
	AuditCheckRunStatusFailed                      AuditCheckRunStatus = "FAILED"
)

type AuditFinding struct {
	// The audit check that generated this result.
	CheckName *string
	// The time the audit started.
	TaskStartTime *time.Time
	// The list of related resources.
	RelatedResources []*RelatedResource
	// The reason the resource was noncompliant.
	ReasonForNonCompliance *string
	// The severity of the result (finding).
	Severity AuditFindingSeverity
	// The time the result (finding) was discovered.
	FindingTime *time.Time
	// A code that indicates the reason that the resource was noncompliant.
	ReasonForNonComplianceCode *string
	// The ID of the audit that generated this result (finding).
	TaskId *string
	// A unique identifier for this set of audit findings. This identifier is used to
	// apply mitigation tasks to one or more sets of findings.
	FindingId *string
	// The resource that was found to be noncompliant with the audit check.
	NonCompliantResource *NonCompliantResource
}

type AuditFindingSeverity string

const (
	AuditFindingSeverityCritical AuditFindingSeverity = "CRITICAL"
	AuditFindingSeverityHigh     AuditFindingSeverity = "HIGH"
	AuditFindingSeverityMedium   AuditFindingSeverity = "MEDIUM"
	AuditFindingSeverityLow      AuditFindingSeverity = "LOW"
)

type AuditFrequency string

const (
	AuditFrequencyDaily    AuditFrequency = "DAILY"
	AuditFrequencyWeekly   AuditFrequency = "WEEKLY"
	AuditFrequencyBiweekly AuditFrequency = "BIWEEKLY"
	AuditFrequencyMonthly  AuditFrequency = "MONTHLY"
)

type AuditMitigationActionExecutionMetadata struct {
	// The unique identifier for the findings to which the task and associated
	// mitigation action are applied.
	FindingId *string
	// The unique identifier for the mitigation action being applied by the task.
	ActionId *string
	// If an error occurred, the code that indicates which type of error occurred.
	ErrorCode *string
	// The current status of the task being executed.
	Status AuditMitigationActionsExecutionStatus
	// If an error occurred, a message that describes the error.
	Message *string
	// The date and time when the task was started.
	StartTime *time.Time
	// The unique identifier for the task that applies the mitigation action.
	TaskId *string
	// The friendly name of the mitigation action being applied by the task.
	ActionName *string
	// The date and time when the task was completed or canceled. Blank if the task is
	// still running.
	EndTime *time.Time
}

type AuditMitigationActionsExecutionStatus string

const (
	AuditMitigationActionsExecutionStatusIn_progress AuditMitigationActionsExecutionStatus = "IN_PROGRESS"
	AuditMitigationActionsExecutionStatusCompleted   AuditMitigationActionsExecutionStatus = "COMPLETED"
	AuditMitigationActionsExecutionStatusFailed      AuditMitigationActionsExecutionStatus = "FAILED"
	AuditMitigationActionsExecutionStatusCanceled    AuditMitigationActionsExecutionStatus = "CANCELED"
	AuditMitigationActionsExecutionStatusSkipped     AuditMitigationActionsExecutionStatus = "SKIPPED"
	AuditMitigationActionsExecutionStatusPending     AuditMitigationActionsExecutionStatus = "PENDING"
)

type AuditMitigationActionsTaskMetadata struct {
	// The unique identifier for the task.
	TaskId *string
	// The time at which the audit mitigation actions task was started.
	StartTime *time.Time
	// The current state of the audit mitigation actions task.
	TaskStatus AuditMitigationActionsTaskStatus
}

type AuditMitigationActionsTaskStatus string

const (
	AuditMitigationActionsTaskStatusIn_progress AuditMitigationActionsTaskStatus = "IN_PROGRESS"
	AuditMitigationActionsTaskStatusCompleted   AuditMitigationActionsTaskStatus = "COMPLETED"
	AuditMitigationActionsTaskStatusFailed      AuditMitigationActionsTaskStatus = "FAILED"
	AuditMitigationActionsTaskStatusCanceled    AuditMitigationActionsTaskStatus = "CANCELED"
)

type AuditMitigationActionsTaskTarget struct {
	// If the task will apply a mitigation action to one or more listed findings, this
	// value uniquely identifies those findings.
	FindingIds []*string
	// Specifies a filter in the form of an audit check and set of reason codes that
	// identify the findings from the audit to which the audit mitigation actions task
	// apply.
	AuditCheckToReasonCodeFilter map[string][]*string
	// If the task will apply a mitigation action to findings from a specific audit,
	// this value uniquely identifies the audit.
	AuditTaskId *string
}

type AuditNotificationTarget struct {
	// The ARN of the role that grants permission to send notifications to the target.
	RoleArn *string
	// The ARN of the target (SNS topic) to which audit notifications are sent.
	TargetArn *string
	// True if notifications to the target are enabled.
	Enabled *bool
}

type AuditNotificationType string

const (
	AuditNotificationTypeSns AuditNotificationType = "SNS"
)

type AuditTaskMetadata struct {
	// The status of this audit. One of "IN_PROGRESS", "COMPLETED", "FAILED", or
	// "CANCELED".
	TaskStatus AuditTaskStatus
	// The ID of this audit.
	TaskId *string
	// The type of this audit. One of "ON_DEMAND_AUDIT_TASK" or "SCHEDULED_AUDIT_TASK".
	TaskType AuditTaskType
}

type AuditTaskStatus string

const (
	AuditTaskStatusIn_progress AuditTaskStatus = "IN_PROGRESS"
	AuditTaskStatusCompleted   AuditTaskStatus = "COMPLETED"
	AuditTaskStatusFailed      AuditTaskStatus = "FAILED"
	AuditTaskStatusCanceled    AuditTaskStatus = "CANCELED"
)

type AuditTaskType string

const (
	AuditTaskTypeOn_demand_audit_task AuditTaskType = "ON_DEMAND_AUDIT_TASK"
	AuditTaskTypeScheduled_audit_task AuditTaskType = "SCHEDULED_AUDIT_TASK"
)

type AuthDecision string

const (
	AuthDecisionAllowed       AuthDecision = "ALLOWED"
	AuthDecisionExplicit_deny AuthDecision = "EXPLICIT_DENY"
	AuthDecisionImplicit_deny AuthDecision = "IMPLICIT_DENY"
)

type AuthInfo struct {
	// The type of action for which the principal is being authorized.
	ActionType ActionType
	// The resources for which the principal is being authorized to perform the
	// specified action.
	Resources []*string
}

type AuthResult struct {
	// The policies and statements that denied the specified action.
	Denied *Denied
	// The final authorization decision of this scenario. Multiple statements are taken
	// into account when determining the authorization decision. An explicit deny
	// statement can override multiple allow statements.
	AuthDecision AuthDecision
	// Authorization information.
	AuthInfo *AuthInfo
	// Contains any missing context values found while evaluating policy.
	MissingContextValues []*string
	// The policies and statements that allowed the specified action.
	Allowed *Allowed
}

type AuthorizerConfig struct {
	// The name of the authorization service for a domain configuration.
	DefaultAuthorizerName *string
	// A Boolean that specifies whether the domain configuration's authorization
	// service can be overridden.
	AllowAuthorizerOverride *bool
}

type AuthorizerDescription struct {
	// The status of the authorizer.
	Status AuthorizerStatus
	// The authorizer ARN.
	AuthorizerArn *string
	// The UNIX timestamp of when the authorizer was last updated.
	LastModifiedDate *time.Time
	// The authorizer's Lambda function ARN.
	AuthorizerFunctionArn *string
	// The authorizer name.
	AuthorizerName *string
	// The public keys used to validate the token signature returned by your custom
	// authentication service.
	TokenSigningPublicKeys map[string]*string
	// The UNIX timestamp of when the authorizer was created.
	CreationDate *time.Time
	// The key used to extract the token from the HTTP headers.
	TokenKeyName *string
	// Specifies whether AWS IoT validates the token signature in an authorization
	// request.
	SigningDisabled *bool
}

type AuthorizerStatus string

const (
	AuthorizerStatusActive   AuthorizerStatus = "ACTIVE"
	AuthorizerStatusInactive AuthorizerStatus = "INACTIVE"
)

type AuthorizerSummary struct {
	// The authorizer ARN.
	AuthorizerArn *string
	// The authorizer name.
	AuthorizerName *string
}

type AutoRegistrationStatus string

const (
	AutoRegistrationStatusEnable  AutoRegistrationStatus = "ENABLE"
	AutoRegistrationStatusDisable AutoRegistrationStatus = "DISABLE"
)

type AwsJobAbortConfig struct {
	// The list of criteria that determine when and how to abort the job.
	AbortCriteriaList []*AwsJobAbortCriteria
}

type AwsJobAbortCriteria struct {
	// The type of job action to take to initiate the job abort.
	Action AwsJobAbortCriteriaAbortAction
	// The type of job execution failures that can initiate a job abort.
	FailureType AwsJobAbortCriteriaFailureType
	// The minimum percentage of job execution failures that must occur to initiate the
	// job abort. AWS IoT supports up to two digits after the decimal (for example,
	// 10.9 and 10.99, but not 10.999).
	ThresholdPercentage *float64
	// The minimum number of things which must receive job execution notifications
	// before the job can be aborted.
	MinNumberOfExecutedThings *int32
}

type AwsJobAbortCriteriaAbortAction string

const (
	AwsJobAbortCriteriaAbortActionCancel AwsJobAbortCriteriaAbortAction = "CANCEL"
)

type AwsJobAbortCriteriaFailureType string

const (
	AwsJobAbortCriteriaFailureTypeFailed    AwsJobAbortCriteriaFailureType = "FAILED"
	AwsJobAbortCriteriaFailureTypeRejected  AwsJobAbortCriteriaFailureType = "REJECTED"
	AwsJobAbortCriteriaFailureTypeTimed_out AwsJobAbortCriteriaFailureType = "TIMED_OUT"
	AwsJobAbortCriteriaFailureTypeAll       AwsJobAbortCriteriaFailureType = "ALL"
)

type AwsJobExecutionsRolloutConfig struct {
	// The maximum number of OTA update job executions started per minute.
	MaximumPerMinute *int32
	// The rate of increase for a job rollout. This parameter allows you to define an
	// exponential rate increase for a job rollout.
	ExponentialRate *AwsJobExponentialRolloutRate
}

type AwsJobExponentialRolloutRate struct {
	// The criteria to initiate the increase in rate of rollout for a job. AWS IoT
	// supports up to one digit after the decimal (for example, 1.5, but not 1.55).
	RateIncreaseCriteria *AwsJobRateIncreaseCriteria
	// The rate of increase for a job rollout. The number of things notified is
	// multiplied by this factor.
	IncrementFactor *float64
	// The minimum number of things that will be notified of a pending job, per minute,
	// at the start of the job rollout. This is the initial rate of the rollout.
	BaseRatePerMinute *int32
}

type AwsJobPresignedUrlConfig struct {
	// How long (in seconds) pre-signed URLs are valid. Valid values are 60 - 3600, the
	// default value is 1800 seconds. Pre-signed URLs are generated when a request for
	// the job document is received.
	ExpiresInSec *int64
}

type AwsJobRateIncreaseCriteria struct {
	// When this number of things have succeeded in their job execution, it will
	// initiate an increase in the rollout rate.
	NumberOfSucceededThings *int32
	// When this number of things have been notified, it will initiate an increase in
	// the rollout rate.
	NumberOfNotifiedThings *int32
}

type AwsJobTimeoutConfig struct {
	// Specifies the amount of time, in minutes, this device has to finish execution of
	// this job. The timeout interval can be anywhere between 1 minute and 7 days (1 to
	// 10080 minutes). The in progress timer can't be updated and will apply to all job
	// executions for the job. Whenever a job execution remains in the IN_PROGRESS
	// status for longer than this interval, the job execution will fail and switch to
	// the terminal TIMED_OUT status.
	InProgressTimeoutInMinutes *int64
}

type Behavior struct {
	// The criteria that determine if a device is behaving normally in regard to the
	// metric.
	Criteria *BehaviorCriteria
	// The name you have given to the behavior.
	Name *string
	// The dimension for a metric in your behavior. For example, using a TOPIC_FILTER
	// dimension, you can narrow down the scope of the metric only to MQTT topics whose
	// name match the pattern specified in the dimension.
	MetricDimension *MetricDimension
	// What is measured by the behavior.
	Metric *string
}

type BehaviorCriteria struct {
	// If a device is in violation of the behavior for the specified number of
	// consecutive datapoints, an alarm occurs. If not specified, the default is 1.
	ConsecutiveDatapointsToAlarm *int32
	// If an alarm has occurred and the offending device is no longer in violation of
	// the behavior for the specified number of consecutive datapoints, the alarm is
	// cleared. If not specified, the default is 1.
	ConsecutiveDatapointsToClear *int32
	// Use this to specify the time duration over which the behavior is evaluated, for
	// those criteria which have a time dimension (for example, NUM_MESSAGES_SENT). For
	// a statisticalThreshhold metric comparison, measurements from all devices are
	// accumulated over this time duration before being used to calculate percentiles,
	// and later, measurements from an individual device are also accumulated over this
	// time duration before being given a percentile rank.
	DurationSeconds *int32
	// The value to be compared with the metric.
	Value *MetricValue
	// The operator that relates the thing measured (metric) to the criteria
	// (containing a value or statisticalThreshold).
	ComparisonOperator ComparisonOperator
	// A statistical ranking (percentile) which indicates a threshold value by which a
	// behavior is determined to be in compliance or in violation of the behavior.
	StatisticalThreshold *StatisticalThreshold
}

type BillingGroupMetadata struct {
	// The date the billing group was created.
	CreationDate *time.Time
}

type BillingGroupProperties struct {
	// The description of the billing group.
	BillingGroupDescription *string
}

type CACertificate struct {
	// The ID of the CA certificate.
	CertificateId *string
	// The date the CA certificate was created.
	CreationDate *time.Time
	// The ARN of the CA certificate.
	CertificateArn *string
	// The status of the CA certificate. The status value REGISTER_INACTIVE is
	// deprecated and should not be used.
	Status CACertificateStatus
}

type CACertificateDescription struct {
	// When the CA certificate is valid.
	Validity *CertificateValidity
	// The status of a CA certificate.
	Status CACertificateStatus
	// The date the CA certificate was created.
	CreationDate *time.Time
	// The owner of the CA certificate.
	OwnedBy *string
	// The customer version of the CA certificate.
	CustomerVersion *int32
	// Whether the CA certificate configured for auto registration of device
	// certificates. Valid values are "ENABLE" and "DISABLE"
	AutoRegistrationStatus AutoRegistrationStatus
	// The CA certificate ARN.
	CertificateArn *string
	// The CA certificate data, in PEM format.
	CertificatePem *string
	// The CA certificate ID.
	CertificateId *string
	// The date the CA certificate was last modified.
	LastModifiedDate *time.Time
	// The generation ID of the CA certificate.
	GenerationId *string
}

type CACertificateStatus string

const (
	CACertificateStatusActive   CACertificateStatus = "ACTIVE"
	CACertificateStatusInactive CACertificateStatus = "INACTIVE"
)

type CACertificateUpdateAction string

const (
	CACertificateUpdateActionDeactivate CACertificateUpdateAction = "DEACTIVATE"
)

type CannedAccessControlList string

const (
	CannedAccessControlListPrivate                CannedAccessControlList = "private"
	CannedAccessControlListPublicread             CannedAccessControlList = "public-read"
	CannedAccessControlListPublicreadwrite        CannedAccessControlList = "public-read-write"
	CannedAccessControlListAwsexecread            CannedAccessControlList = "aws-exec-read"
	CannedAccessControlListAuthenticatedread      CannedAccessControlList = "authenticated-read"
	CannedAccessControlListBucketownerread        CannedAccessControlList = "bucket-owner-read"
	CannedAccessControlListBucketownerfullcontrol CannedAccessControlList = "bucket-owner-full-control"
	CannedAccessControlListLogdeliverywrite       CannedAccessControlList = "log-delivery-write"
)

type Certificate struct {
	// The ARN of the certificate.
	CertificateArn *string
	// The status of the certificate. The status value REGISTER_INACTIVE is deprecated
	// and should not be used.
	Status CertificateStatus
	// The date and time the certificate was created.
	CreationDate *time.Time
	// The ID of the certificate. (The last part of the certificate ARN contains the
	// certificate ID.)
	CertificateId *string
	// The mode of the certificate.
	CertificateMode CertificateMode
}

type CertificateConflictException struct {
	Message *string
}

type CertificateDescription struct {
	// The mode of the certificate.
	CertificateMode CertificateMode
	// The certificate data, in PEM format.
	CertificatePem *string
	// The certificate ID of the CA certificate used to sign this certificate.
	CaCertificateId *string
	// The date and time the certificate was created.
	CreationDate *time.Time
	// The ID of the certificate.
	CertificateId *string
	// The transfer data.
	TransferData *TransferData
	// The ID of the AWS account of the previous owner of the certificate.
	PreviousOwnedBy *string
	// The date and time the certificate was last modified.
	LastModifiedDate *time.Time
	// The generation ID of the certificate.
	GenerationId *string
	// The customer version of the certificate.
	CustomerVersion *int32
	// The status of the certificate.
	Status CertificateStatus
	// The ID of the AWS account that owns the certificate.
	OwnedBy *string
	// When the certificate is valid.
	Validity *CertificateValidity
	// The ARN of the certificate.
	CertificateArn *string
}

type CertificateMode string

const (
	CertificateModeDefault  CertificateMode = "DEFAULT"
	CertificateModeSni_only CertificateMode = "SNI_ONLY"
)

type CertificateStateException struct {
	Message *string
}

type CertificateStatus string

const (
	CertificateStatusActive             CertificateStatus = "ACTIVE"
	CertificateStatusInactive           CertificateStatus = "INACTIVE"
	CertificateStatusRevoked            CertificateStatus = "REVOKED"
	CertificateStatusPending_transfer   CertificateStatus = "PENDING_TRANSFER"
	CertificateStatusRegister_inactive  CertificateStatus = "REGISTER_INACTIVE"
	CertificateStatusPending_activation CertificateStatus = "PENDING_ACTIVATION"
)

type CertificateValidationException struct {
	Message *string
}

type CertificateValidity struct {
	// The certificate is not valid after this date.
	NotAfter *time.Time
	// The certificate is not valid before this date.
	NotBefore *time.Time
}

type CloudwatchAlarmAction struct {
	// The CloudWatch alarm name.
	AlarmName *string
	// The IAM role that allows access to the CloudWatch alarm.
	RoleArn *string
	// The reason for the alarm change.
	StateReason *string
	// The value of the alarm state. Acceptable values are: OK, ALARM,
	// INSUFFICIENT_DATA.
	StateValue *string
}

type CloudwatchLogsAction struct {
	// The IAM role that allows access to the CloudWatch log.
	RoleArn *string
	// The CloudWatch log group to which the action sends data.
	LogGroupName *string
}

type CloudwatchMetricAction struct {
	// The CloudWatch metric namespace name.
	MetricNamespace *string
	// The metric unit
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#Unit)
	// supported by CloudWatch.
	MetricUnit *string
	// The CloudWatch metric name.
	MetricName *string
	// The IAM role that allows access to the CloudWatch metric.
	RoleArn *string
	// An optional Unix timestamp
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#about_timestamp).
	MetricTimestamp *string
	// The CloudWatch metric value.
	MetricValue *string
}

type CodeSigning struct {
	// A custom method for code signing a file.
	CustomCodeSigning *CustomCodeSigning
	// Describes the code-signing job.
	StartSigningJobParameter *StartSigningJobParameter
	// The ID of the AWSSignerJob which was created to sign the file.
	AwsSignerJobId *string
}

type CodeSigningCertificateChain struct {
	// The name of the certificate.
	CertificateName *string
	// A base64 encoded binary representation of the code signing certificate chain.
	InlineDocument *string
}

type CodeSigningSignature struct {
	// A base64 encoded binary representation of the code signing signature.
	InlineDocument []byte
}

type ComparisonOperator string

const (
	ComparisonOperatorLess_than           ComparisonOperator = "less-than"
	ComparisonOperatorLess_than_equals    ComparisonOperator = "less-than-equals"
	ComparisonOperatorGreater_than        ComparisonOperator = "greater-than"
	ComparisonOperatorGreater_than_equals ComparisonOperator = "greater-than-equals"
	ComparisonOperatorIn_cidr_set         ComparisonOperator = "in-cidr-set"
	ComparisonOperatorNot_in_cidr_set     ComparisonOperator = "not-in-cidr-set"
	ComparisonOperatorIn_port_set         ComparisonOperator = "in-port-set"
	ComparisonOperatorNot_in_port_set     ComparisonOperator = "not-in-port-set"
)

type Configuration struct {
	// True to enable the configuration.
	Enabled *bool
}

type ConflictingResourceUpdateException struct {
	Message *string
}

type CustomCodeSigning struct {
	// The signature algorithm used to code sign the file.
	SignatureAlgorithm *string
	// The certificate chain.
	CertificateChain *CodeSigningCertificateChain
	// The hash algorithm used to code sign the file.
	HashAlgorithm *string
	// The signature for the file.
	Signature *CodeSigningSignature
}

type DayOfWeek string

const (
	DayOfWeekSun DayOfWeek = "SUN"
	DayOfWeekMon DayOfWeek = "MON"
	DayOfWeekTue DayOfWeek = "TUE"
	DayOfWeekWed DayOfWeek = "WED"
	DayOfWeekThu DayOfWeek = "THU"
	DayOfWeekFri DayOfWeek = "FRI"
	DayOfWeekSat DayOfWeek = "SAT"
)

type DeleteConflictException struct {
	Message *string
}

type Denied struct {
	// Information that explicitly denies the authorization.
	ExplicitDeny *ExplicitDeny
	// Information that implicitly denies the authorization. When a policy doesn't
	// explicitly deny or allow an action on a resource it is considered an implicit
	// deny.
	ImplicitDeny *ImplicitDeny
}

type Destination struct {
	// Describes the location in S3 of the updated firmware.
	S3Destination *S3Destination
}

type DeviceCertificateUpdateAction string

const (
	DeviceCertificateUpdateActionDeactivate DeviceCertificateUpdateAction = "DEACTIVATE"
)

type DimensionType string

const (
	DimensionTypeTopic_filter DimensionType = "TOPIC_FILTER"
)

type DimensionValueOperator string

const (
	DimensionValueOperatorIn     DimensionValueOperator = "IN"
	DimensionValueOperatorNot_in DimensionValueOperator = "NOT_IN"
)

type DomainConfigurationStatus string

const (
	DomainConfigurationStatusEnabled  DomainConfigurationStatus = "ENABLED"
	DomainConfigurationStatusDisabled DomainConfigurationStatus = "DISABLED"
)

type DomainConfigurationSummary struct {
	// The type of service delivered by the endpoint.
	ServiceType ServiceType
	// The name of the domain configuration. This value must be unique to a region.
	DomainConfigurationName *string
	// The ARN of the domain configuration.
	DomainConfigurationArn *string
}

type DomainType string

const (
	DomainTypeEndpoint         DomainType = "ENDPOINT"
	DomainTypeAws_managed      DomainType = "AWS_MANAGED"
	DomainTypeCustomer_managed DomainType = "CUSTOMER_MANAGED"
)

type DynamicGroupStatus string

const (
	DynamicGroupStatusActive     DynamicGroupStatus = "ACTIVE"
	DynamicGroupStatusBuilding   DynamicGroupStatus = "BUILDING"
	DynamicGroupStatusRebuilding DynamicGroupStatus = "REBUILDING"
)

type DynamoDBAction struct {
	// The hash key value.
	HashKeyValue *string
	// The range key name.
	RangeKeyField *string
	// The type of operation to be performed. This follows the substitution template,
	// so it can be ${operation}, but the substitution must result in one of the
	// following: INSERT, UPDATE, or DELETE.
	Operation *string
	// The ARN of the IAM role that grants access to the DynamoDB table.
	RoleArn *string
	// The action payload. This name can be customized.
	PayloadField *string
	// The name of the DynamoDB table.
	TableName *string
	// The hash key type. Valid values are "STRING" or "NUMBER"
	HashKeyType DynamoKeyType
	// The hash key name.
	HashKeyField *string
	// The range key value.
	RangeKeyValue *string
	// The range key type. Valid values are "STRING" or "NUMBER"
	RangeKeyType DynamoKeyType
}

type DynamoDBv2Action struct {
	// Specifies the DynamoDB table to which the message data will be written. For
	// example: { "dynamoDBv2": { "roleArn": "aws:iam:12341251:my-role" "putItem": {
	// "tableName": "my-table" } } } Each attribute in the message payload will be
	// written to a separate column in the DynamoDB database.
	PutItem *PutItemInput
	// The ARN of the IAM role that grants access to the DynamoDB table.
	RoleArn *string
}

type DynamoKeyType string

const (
	DynamoKeyTypeString DynamoKeyType = "STRING"
	DynamoKeyTypeNumber DynamoKeyType = "NUMBER"
)

type EffectivePolicy struct {
	// The policy name.
	PolicyName *string
	// The policy ARN.
	PolicyArn *string
	// The IAM policy document.
	PolicyDocument *string
}

type ElasticsearchAction struct {
	// The Elasticsearch index where you want to store your data.
	Index *string
	// The endpoint of your Elasticsearch domain.
	Endpoint *string
	// The unique identifier for the document you are storing.
	Id *string
	// The type of document you are storing.
	Type *string
	// The IAM role ARN that has access to Elasticsearch.
	RoleArn *string
}

type EnableIoTLoggingParams struct {
	// The ARN of the IAM role used for logging.
	RoleArnForLogging *string
	// Specifies the types of information to be logged.
	LogLevel LogLevel
}

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

type EventType string

const (
	EventTypeThing                  EventType = "THING"
	EventTypeThing_group            EventType = "THING_GROUP"
	EventTypeThing_type             EventType = "THING_TYPE"
	EventTypeThing_group_membership EventType = "THING_GROUP_MEMBERSHIP"
	EventTypeThing_group_hierarchy  EventType = "THING_GROUP_HIERARCHY"
	EventTypeThing_type_association EventType = "THING_TYPE_ASSOCIATION"
	EventTypeJob                    EventType = "JOB"
	EventTypeJob_execution          EventType = "JOB_EXECUTION"
	EventTypePolicy                 EventType = "POLICY"
	EventTypeCertificate            EventType = "CERTIFICATE"
	EventTypeCa_certificate         EventType = "CA_CERTIFICATE"
)

type ExplicitDeny struct {
	// The policies that denied the authorization.
	Policies []*Policy
}

type ExponentialRolloutRate struct {
	// The criteria to initiate the increase in rate of rollout for a job. AWS IoT
	// supports up to one digit after the decimal (for example, 1.5, but not 1.55).
	RateIncreaseCriteria *RateIncreaseCriteria
	// The minimum number of things that will be notified of a pending job, per minute
	// at the start of job rollout. This parameter allows you to define the initial
	// rate of rollout.
	BaseRatePerMinute *int32
	// The exponential factor to increase the rate of rollout for a job.
	IncrementFactor *float64
}

type Field struct {
	// The datatype of the field.
	Type FieldType
	// The name of the field.
	Name *string
}

type FieldType string

const (
	FieldTypeNumber  FieldType = "Number"
	FieldTypeString  FieldType = "String"
	FieldTypeBoolean FieldType = "Boolean"
)

type FileLocation struct {
	// The location of the updated firmware in S3.
	S3Location *S3Location
	// The stream that contains the OTA update.
	Stream *Stream
}

type FirehoseAction struct {
	// The IAM role that grants access to the Amazon Kinesis Firehose stream.
	RoleArn *string
	// A character separator that will be used to separate records written to the
	// Firehose stream. Valid values are: '\n' (newline), '\t' (tab), '\r\n' (Windows
	// newline), ',' (comma).
	Separator *string
	// The delivery stream name.
	DeliveryStreamName *string
}

type GroupNameAndArn struct {
	// The group ARN.
	GroupArn *string
	// The group name.
	GroupName *string
}

type HttpAction struct {
	// The HTTP headers to send with the message data.
	Headers []*HttpActionHeader
	// The endpoint URL. If substitution templates are used in the URL, you must also
	// specify a confirmationUrl. If this is a new destination, a new
	// TopicRuleDestination is created if possible.
	Url *string
	// The authentication method to use when sending data to an HTTPS endpoint.
	Auth *HttpAuthorization
	// The URL to which AWS IoT sends a confirmation message. The value of the
	// confirmation URL must be a prefix of the endpoint URL. If you do not specify a
	// confirmation URL AWS IoT uses the endpoint URL as the confirmation URL. If you
	// use substitution templates in the confirmationUrl, you must create and enable
	// topic rule destinations that match each possible value of the substitution
	// template before traffic is allowed to your endpoint URL.
	ConfirmationUrl *string
}

type HttpActionHeader struct {
	// The HTTP header value. Substitution templates are supported.
	Value *string
	// The HTTP header key.
	Key *string
}

type HttpAuthorization struct {
	// Use Sig V4 authorization. For more information, see Signature Version 4 Signing
	// Process
	// (https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
	Sigv4 *SigV4Authorization
}

type HttpContext struct {
	// The header keys and values in an HTTP authorization request.
	Headers map[string]*string
	// The query string keys and values in an HTTP authorization request.
	QueryString *string
}

type HttpUrlDestinationConfiguration struct {
	// The URL AWS IoT uses to confirm ownership of or access to the topic rule
	// destination URL.
	ConfirmationUrl *string
}

type HttpUrlDestinationProperties struct {
	// The URL used to confirm the HTTP topic rule destination URL.
	ConfirmationUrl *string
}

type HttpUrlDestinationSummary struct {
	// The URL used to confirm ownership of or access to the HTTP topic rule
	// destination URL.
	ConfirmationUrl *string
}

type ImplicitDeny struct {
	// Policies that don't contain a matching allow or deny statement for the specified
	// action on the specified resource.
	Policies []*Policy
}

type IndexNotReadyException struct {
	Message *string
}

type IndexStatus string

const (
	IndexStatusActive     IndexStatus = "ACTIVE"
	IndexStatusBuilding   IndexStatus = "BUILDING"
	IndexStatusRebuilding IndexStatus = "REBUILDING"
)

type InternalException struct {
	Message *string
}

type InternalFailureException struct {
	Message *string
}

type InvalidAggregationException struct {
	Message *string
}

type InvalidQueryException struct {
	Message *string
}

type InvalidRequestException struct {
	Message *string
}

type InvalidResponseException struct {
	Message *string
}

type InvalidStateTransitionException struct {
	Message *string
}

type IotAnalyticsAction struct {
	// The name of the IoT Analytics channel to which message data will be sent.
	ChannelName *string
	// The ARN of the role which has a policy that grants IoT Analytics permission to
	// send message data via IoT Analytics (iotanalytics:BatchPutMessage).
	RoleArn *string
	// (deprecated) The ARN of the IoT Analytics channel to which message data will be
	// sent.
	ChannelArn *string
}

type IotEventsAction struct {
	// The ARN of the role that grants AWS IoT permission to send an input to an AWS
	// IoT Events detector. ("Action":"iotevents:BatchPutMessage").
	RoleArn *string
	// [Optional] Use this to ensure that only one input (message) with a given
	// messageId will be processed by an AWS IoT Events detector.
	MessageId *string
	// The name of the AWS IoT Events input.
	InputName *string
}

type IotSiteWiseAction struct {
	// The ARN of the role that grants AWS IoT permission to send an asset property
	// value to AWS IoTSiteWise. ("Action": "iotsitewise:BatchPutAssetPropertyValue").
	// The trust policy can restrict access to specific asset hierarchy paths.
	RoleArn *string
	// A list of asset property value entries.
	PutAssetPropertyValueEntries []*PutAssetPropertyValueEntry
}

type Job struct {
	// Configuration for pre-signed S3 URLs.
	PresignedUrlConfig *PresignedUrlConfig
	// Allows you to create a staged rollout of a job.
	JobExecutionsRolloutConfig *JobExecutionsRolloutConfig
	// If the job was updated, provides the reason code for the update.
	ReasonCode *string
	// A list of IoT things and thing groups to which the job should be sent.
	Targets []*string
	// Details about the job process.
	JobProcessDetails *JobProcessDetails
	// A short text description of the job.
	Description *string
	// Specifies whether the job will continue to run (CONTINUOUS), or will be complete
	// after all those things specified as targets have completed the job (SNAPSHOT).
	// If continuous, the job may also be run on a thing when a change is detected in a
	// target. For example, a job will run on a device when the thing representing the
	// device is added to a target group, even after the job was completed by all
	// things originally in the group.
	TargetSelection TargetSelection
	// If the job was updated, describes the reason for the update.
	Comment *string
	// The time, in seconds since the epoch, when the job was last updated.
	LastUpdatedAt *time.Time
	// An ARN identifying the job with format "arn:aws:iot:region:account:job/jobId".
	JobArn *string
	// Specifies the amount of time each device has to finish its execution of the job.
	// A timer is started when the job execution status is set to IN_PROGRESS. If the
	// job execution status is not set to another terminal state before the timer
	// expires, it will be automatically set to TIMED_OUT.
	TimeoutConfig *TimeoutConfig
	// The time, in seconds since the epoch, when the job was created.
	CreatedAt *time.Time
	// The time, in seconds since the epoch, when the job was completed.
	CompletedAt *time.Time
	// The unique identifier you assigned to this job when it was created.
	JobId *string
	// Will be true if the job was canceled with the optional force parameter set to
	// true.
	ForceCanceled *bool
	// The status of the job, one of IN_PROGRESS, CANCELED, DELETION_IN_PROGRESS or
	// COMPLETED.
	Status JobStatus
	// Configuration for criteria to abort the job.
	AbortConfig *AbortConfig
}

type JobExecution struct {
	// The version of the job execution. Job execution versions are incremented each
	// time they are updated by a device.
	VersionNumber *int64
	// The unique identifier you assigned to the job when it was created.
	JobId *string
	// The time, in seconds since the epoch, when the job execution was last updated.
	LastUpdatedAt *time.Time
	// Will be true if the job execution was canceled with the optional force parameter
	// set to true.
	ForceCanceled *bool
	// A collection of name/value pairs that describe the status of the job execution.
	StatusDetails *JobExecutionStatusDetails
	// The time, in seconds since the epoch, when the job execution started.
	StartedAt *time.Time
	// A string (consisting of the digits "0" through "9") which identifies this
	// particular job execution on this particular device. It can be used in commands
	// which return or update job execution information.
	ExecutionNumber *int64
	// The ARN of the thing on which the job execution is running.
	ThingArn *string
	// The status of the job execution (IN_PROGRESS, QUEUED, FAILED, SUCCEEDED,
	// TIMED_OUT, CANCELED, or REJECTED).
	Status JobExecutionStatus
	// The estimated number of seconds that remain before the job execution status will
	// be changed to TIMED_OUT. The timeout interval can be anywhere between 1 minute
	// and 7 days (1 to 10080 minutes). The actual job execution timeout can occur up
	// to 60 seconds later than the estimated duration. This value will not be included
	// if the job execution has reached a terminal status.
	ApproximateSecondsBeforeTimedOut *int64
	// The time, in seconds since the epoch, when the job execution was queued.
	QueuedAt *time.Time
}

type JobExecutionFailureType string

const (
	JobExecutionFailureTypeFailed    JobExecutionFailureType = "FAILED"
	JobExecutionFailureTypeRejected  JobExecutionFailureType = "REJECTED"
	JobExecutionFailureTypeTimed_out JobExecutionFailureType = "TIMED_OUT"
	JobExecutionFailureTypeAll       JobExecutionFailureType = "ALL"
)

type JobExecutionStatus string

const (
	JobExecutionStatusQueued      JobExecutionStatus = "QUEUED"
	JobExecutionStatusIn_progress JobExecutionStatus = "IN_PROGRESS"
	JobExecutionStatusSucceeded   JobExecutionStatus = "SUCCEEDED"
	JobExecutionStatusFailed      JobExecutionStatus = "FAILED"
	JobExecutionStatusTimed_out   JobExecutionStatus = "TIMED_OUT"
	JobExecutionStatusRejected    JobExecutionStatus = "REJECTED"
	JobExecutionStatusRemoved     JobExecutionStatus = "REMOVED"
	JobExecutionStatusCanceled    JobExecutionStatus = "CANCELED"
)

type JobExecutionStatusDetails struct {
	// The job execution status.
	DetailsMap map[string]*string
}

type JobExecutionSummary struct {
	// The time, in seconds since the epoch, when the job execution was queued.
	QueuedAt *time.Time
	// The time, in seconds since the epoch, when the job execution was last updated.
	LastUpdatedAt *time.Time
	// A string (consisting of the digits "0" through "9") which identifies this
	// particular job execution on this particular device. It can be used later in
	// commands which return or update job execution information.
	ExecutionNumber *int64
	// The time, in seconds since the epoch, when the job execution started.
	StartedAt *time.Time
	// The status of the job execution.
	Status JobExecutionStatus
}

type JobExecutionSummaryForJob struct {
	// The ARN of the thing on which the job execution is running.
	ThingArn *string
	// Contains a subset of information about a job execution.
	JobExecutionSummary *JobExecutionSummary
}

type JobExecutionSummaryForThing struct {
	// The unique identifier you assigned to this job when it was created.
	JobId *string
	// Contains a subset of information about a job execution.
	JobExecutionSummary *JobExecutionSummary
}

type JobExecutionsRolloutConfig struct {
	// The rate of increase for a job rollout. This parameter allows you to define an
	// exponential rate for a job rollout.
	ExponentialRate *ExponentialRolloutRate
	// The maximum number of things that will be notified of a pending job, per minute.
	// This parameter allows you to create a staged rollout.
	MaximumPerMinute *int32
}

type JobProcessDetails struct {
	// The number of things that rejected the job.
	NumberOfRejectedThings *int32
	// The number of things whose job execution status is TIMED_OUT.
	NumberOfTimedOutThings *int32
	// The number of things currently executing the job.
	NumberOfInProgressThings *int32
	// The number of things that are awaiting execution of the job.
	NumberOfQueuedThings *int32
	// The target devices to which the job execution is being rolled out. This value
	// will be null after the job execution has finished rolling out to all the target
	// devices.
	ProcessingTargets []*string
	// The number of things that are no longer scheduled to execute the job because
	// they have been deleted or have been removed from the group that was a target of
	// the job.
	NumberOfRemovedThings *int32
	// The number of things that failed executing the job.
	NumberOfFailedThings *int32
	// The number of things which successfully completed the job.
	NumberOfSucceededThings *int32
	// The number of things that cancelled the job.
	NumberOfCanceledThings *int32
}

type JobStatus string

const (
	JobStatusIn_progress          JobStatus = "IN_PROGRESS"
	JobStatusCanceled             JobStatus = "CANCELED"
	JobStatusCompleted            JobStatus = "COMPLETED"
	JobStatusDeletion_in_progress JobStatus = "DELETION_IN_PROGRESS"
)

type JobSummary struct {
	// Specifies whether the job will continue to run (CONTINUOUS), or will be complete
	// after all those things specified as targets have completed the job (SNAPSHOT).
	// If continuous, the job may also be run on a thing when a change is detected in a
	// target. For example, a job will run on a thing when the thing is added to a
	// target group, even after the job was completed by all things originally in the
	// group.
	TargetSelection TargetSelection
	// The time, in seconds since the epoch, when the job was last updated.
	LastUpdatedAt *time.Time
	// The job summary status.
	Status JobStatus
	// The ID of the thing group.
	ThingGroupId *string
	// The unique identifier you assigned to this job when it was created.
	JobId *string
	// The time, in seconds since the epoch, when the job was created.
	CreatedAt *time.Time
	// The job ARN.
	JobArn *string
	// The time, in seconds since the epoch, when the job completed.
	CompletedAt *time.Time
}

type KeyPair struct {
	// The private key.
	PrivateKey *string
	// The public key.
	PublicKey *string
}

type KinesisAction struct {
	// The name of the Amazon Kinesis stream.
	StreamName *string
	// The ARN of the IAM role that grants access to the Amazon Kinesis stream.
	RoleArn *string
	// The partition key.
	PartitionKey *string
}

type LambdaAction struct {
	// The ARN of the Lambda function.
	FunctionArn *string
}

type LimitExceededException struct {
	Message *string
}

type LogLevel string

const (
	LogLevelDebug    LogLevel = "DEBUG"
	LogLevelInfo     LogLevel = "INFO"
	LogLevelError    LogLevel = "ERROR"
	LogLevelWarn     LogLevel = "WARN"
	LogLevelDisabled LogLevel = "DISABLED"
)

type LogTarget struct {
	// The target name.
	TargetName *string
	// The target type.
	TargetType LogTargetType
}

type LogTargetConfiguration struct {
	// The logging level.
	LogLevel LogLevel
	// A log target
	LogTarget *LogTarget
}

type LogTargetType string

const (
	LogTargetTypeDefault     LogTargetType = "DEFAULT"
	LogTargetTypeThing_group LogTargetType = "THING_GROUP"
)

type LoggingOptionsPayload struct {
	// The ARN of the IAM role that grants access.
	RoleArn *string
	// The log level.
	LogLevel LogLevel
}

type MalformedPolicyException struct {
	Message *string
}

type MessageFormat string

const (
	MessageFormatRaw  MessageFormat = "RAW"
	MessageFormatJson MessageFormat = "JSON"
)

type MetricDimension struct {
	// Defines how the dimensionValues of a dimension are interpreted. For example, for
	// dimension type TOPIC_FILTER, the IN operator, a message will be counted only if
	// its topic matches one of the topic filters. With NOT_IN operator, a message will
	// be counted only if it doesn't match any of the topic filters. The operator is
	// optional: if it's not provided (is null), it will be interpreted as IN.
	Operator DimensionValueOperator
	// A unique identifier for the dimension.
	DimensionName *string
}

type MetricToRetain struct {
	// What is measured by the behavior.
	Metric *string
	// The dimension of a metric.
	MetricDimension *MetricDimension
}

type MetricValue struct {
	// If the comparisonOperator calls for a set of ports, use this to specify that set
	// to be compared with the metric.
	Ports []*int32
	// If the comparisonOperator calls for a set of CIDRs, use this to specify that set
	// to be compared with the metric.
	Cidrs []*string
	// If the comparisonOperator calls for a numeric value, use this to specify that
	// numeric value to be compared with the metric.
	Count *int64
}

type MitigationAction struct {
	// The set of parameters for this mitigation action. The parameters vary, depending
	// on the kind of action you apply.
	ActionParams *MitigationActionParams
	// A unique identifier for the mitigation action.
	Id *string
	// The IAM role ARN used to apply this mitigation action.
	RoleArn *string
	// A user-friendly name for the mitigation action.
	Name *string
}

type MitigationActionIdentifier struct {
	// The friendly name of the mitigation action.
	ActionName *string
	// The IAM role ARN used to apply this mitigation action.
	ActionArn *string
	// The date when this mitigation action was created.
	CreationDate *time.Time
}

type MitigationActionParams struct {
	// Parameters to define a mitigation action that moves devices associated with a
	// certificate to one or more specified thing groups, typically for quarantine.
	AddThingsToThingGroupParams *AddThingsToThingGroupParams
	// Parameters to define a mitigation action that changes the state of the device
	// certificate to inactive.
	UpdateDeviceCertificateParams *UpdateDeviceCertificateParams
	// Parameters to define a mitigation action that enables AWS IoT logging at a
	// specified level of detail.
	EnableIoTLoggingParams *EnableIoTLoggingParams
	// Parameters to define a mitigation action that publishes findings to Amazon SNS.
	// You can implement your own custom actions in response to the Amazon SNS
	// messages.
	PublishFindingToSnsParams *PublishFindingToSnsParams
	// Parameters to define a mitigation action that changes the state of the CA
	// certificate to inactive.
	UpdateCACertificateParams *UpdateCACertificateParams
	// Parameters to define a mitigation action that adds a blank policy to restrict
	// permissions.
	ReplaceDefaultPolicyVersionParams *ReplaceDefaultPolicyVersionParams
}

type MitigationActionType string

const (
	MitigationActionTypeUpdate_device_certificate      MitigationActionType = "UPDATE_DEVICE_CERTIFICATE"
	MitigationActionTypeUpdate_ca_certificate          MitigationActionType = "UPDATE_CA_CERTIFICATE"
	MitigationActionTypeAdd_things_to_thing_group      MitigationActionType = "ADD_THINGS_TO_THING_GROUP"
	MitigationActionTypeReplace_default_policy_version MitigationActionType = "REPLACE_DEFAULT_POLICY_VERSION"
	MitigationActionTypeEnable_iot_logging             MitigationActionType = "ENABLE_IOT_LOGGING"
	MitigationActionTypePublish_finding_to_sns         MitigationActionType = "PUBLISH_FINDING_TO_SNS"
)

type MqttContext struct {
	// The value of the username key in an MQTT authorization request.
	Username *string
	// The value of the clientId key in an MQTT authorization request.
	ClientId *string
	// The value of the password key in an MQTT authorization request.
	Password []byte
}

type NonCompliantResource struct {
	// Other information about the noncompliant resource.
	AdditionalInfo map[string]*string
	// Information that identifies the noncompliant resource.
	ResourceIdentifier *ResourceIdentifier
	// The type of the noncompliant resource.
	ResourceType ResourceType
}

type NotConfiguredException struct {
	Message *string
}

type OTAUpdateFile struct {
	// A list of name/attribute pairs.
	Attributes map[string]*string
	// The file version.
	FileVersion *string
	// The location of the updated firmware.
	FileLocation *FileLocation
	// The name of the file.
	FileName *string
	// The code signing method of the file.
	CodeSigning *CodeSigning
}

type OTAUpdateInfo struct {
	// The AWS IoT job ID associated with the OTA update.
	AwsIotJobId *string
	// A list of files associated with the OTA update.
	OtaUpdateFiles []*OTAUpdateFile
	// A description of the OTA update.
	Description *string
	// The OTA update ARN.
	OtaUpdateArn *string
	// The date when the OTA update was last updated.
	LastModifiedDate *time.Time
	// A collection of name/value pairs
	AdditionalParameters map[string]*string
	// Error information associated with the OTA update.
	ErrorInfo *ErrorInfo
	// Configuration for the rollout of OTA updates.
	AwsJobExecutionsRolloutConfig *AwsJobExecutionsRolloutConfig
	// The AWS IoT job ARN associated with the OTA update.
	AwsIotJobArn *string
	// The status of the OTA update.
	OtaUpdateStatus OTAUpdateStatus
	// Configuration information for pre-signed URLs. Valid when protocols contains
	// HTTP.
	AwsJobPresignedUrlConfig *AwsJobPresignedUrlConfig
	// The OTA update ID.
	OtaUpdateId *string
	// The protocol used to transfer the OTA update image. Valid values are [HTTP],
	// [MQTT], [HTTP, MQTT]. When both HTTP and MQTT are specified, the target device
	// can choose the protocol.
	Protocols []Protocol
	// The date when the OTA update was created.
	CreationDate *time.Time
	// The targets of the OTA update.
	Targets []*string
	// Specifies whether the OTA update will continue to run (CONTINUOUS), or will be
	// complete after all those things specified as targets have completed the OTA
	// update (SNAPSHOT). If continuous, the OTA update may also be run on a thing when
	// a change is detected in a target. For example, an OTA update will run on a thing
	// when the thing is added to a target group, even after the OTA update was
	// completed by all things originally in the group.
	TargetSelection TargetSelection
}

type OTAUpdateStatus string

const (
	OTAUpdateStatusCreate_pending     OTAUpdateStatus = "CREATE_PENDING"
	OTAUpdateStatusCreate_in_progress OTAUpdateStatus = "CREATE_IN_PROGRESS"
	OTAUpdateStatusCreate_complete    OTAUpdateStatus = "CREATE_COMPLETE"
	OTAUpdateStatusCreate_failed      OTAUpdateStatus = "CREATE_FAILED"
)

type OTAUpdateSummary struct {
	// The OTA update ARN.
	OtaUpdateArn *string
	// The date when the OTA update was created.
	CreationDate *time.Time
	// The OTA update ID.
	OtaUpdateId *string
}

type OutgoingCertificate struct {
	// The certificate ARN.
	CertificateArn *string
	// The certificate ID.
	CertificateId *string
	// The AWS account to which the transfer was made.
	TransferredTo *string
	// The certificate creation date.
	CreationDate *time.Time
	// The date the transfer was initiated.
	TransferDate *time.Time
	// The transfer message.
	TransferMessage *string
}

type PercentPair struct {
	// The percentile.
	Percent *float64
	// The value of the percentile.
	Value *float64
}

type Policy struct {
	// The policy name.
	PolicyName *string
	// The policy ARN.
	PolicyArn *string
}

type PolicyTemplateName string

const (
	PolicyTemplateNameBlank_policy PolicyTemplateName = "BLANK_POLICY"
)

type PolicyVersion struct {
	// The date and time the policy was created.
	CreateDate *time.Time
	// Specifies whether the policy version is the default.
	IsDefaultVersion *bool
	// The policy version ID.
	VersionId *string
}

type PolicyVersionIdentifier struct {
	// The name of the policy.
	PolicyName *string
	// The ID of the version of the policy associated with the resource.
	PolicyVersionId *string
}

type PresignedUrlConfig struct {
	// How long (in seconds) pre-signed URLs are valid. Valid values are 60 - 3600, the
	// default value is 3600 seconds. Pre-signed URLs are generated when Jobs receives
	// an MQTT request for the job document.
	ExpiresInSec *int64
	// The ARN of an IAM role that grants grants permission to download files from the
	// S3 bucket where the job data/updates are stored. The role must also grant
	// permission for IoT to download the files.
	RoleArn *string
}

type Protocol string

const (
	ProtocolMqtt Protocol = "MQTT"
	ProtocolHttp Protocol = "HTTP"
)

type ProvisioningHook struct {
	// The payload that was sent to the target function. Note: Only Lambda functions
	// are currently supported.
	PayloadVersion *string
	// The ARN of the target function. Note: Only Lambda functions are currently
	// supported.
	TargetArn *string
}

type ProvisioningTemplateSummary struct {
	// True if the fleet provision template is enabled, otherwise false.
	Enabled *bool
	// The date when the fleet provisioning template summary was created.
	CreationDate *time.Time
	// The ARN of the fleet provisioning template.
	TemplateArn *string
	// The description of the fleet provisioning template.
	Description *string
	// The name of the fleet provisioning template.
	TemplateName *string
	// The date when the fleet provisioning template summary was last modified.
	LastModifiedDate *time.Time
}

type ProvisioningTemplateVersionSummary struct {
	// The ID of the fleet privisioning template version.
	VersionId *int32
	// True if the fleet provisioning template version is the default version,
	// otherwise false.
	IsDefaultVersion *bool
	// The date when the fleet provisioning template version was created
	CreationDate *time.Time
}

type PublishFindingToSnsParams struct {
	// The ARN of the topic to which you want to publish the findings.
	TopicArn *string
}

type PutAssetPropertyValueEntry struct {
	// A list of property values to insert that each contain timestamp, quality, and
	// value (TQV) information.
	PropertyValues []*AssetPropertyValue
	// Optional. A unique identifier for this entry that you can define to better track
	// which message caused an error in case of failure. Accepts substitution
	// templates. Defaults to a new UUID.
	EntryId *string
	// The ID of the AWS IoT SiteWise asset. You must specify either a propertyAlias or
	// both an aliasId and a propertyId. Accepts substitution templates.
	AssetId *string
	// The name of the property alias associated with your asset property. You must
	// specify either a propertyAlias or both an aliasId and a propertyId. Accepts
	// substitution templates.
	PropertyAlias *string
	// The ID of the asset's property. You must specify either a propertyAlias or both
	// an aliasId and a propertyId. Accepts substitution templates.
	PropertyId *string
}

type PutItemInput struct {
	// The table where the message data will be written.
	TableName *string
}

type RateIncreaseCriteria struct {
	// The threshold for number of notified things that will initiate the increase in
	// rate of rollout.
	NumberOfNotifiedThings *int32
	// The threshold for number of succeeded things that will initiate the increase in
	// rate of rollout.
	NumberOfSucceededThings *int32
}

type RegistrationCodeValidationException struct {
	Message *string
}

type RegistrationConfig struct {
	// The template body.
	TemplateBody *string
	// The ARN of the role.
	RoleArn *string
}

type RelatedResource struct {
	// Information that identifies the resource.
	ResourceIdentifier *ResourceIdentifier
	// Other information about the resource.
	AdditionalInfo map[string]*string
	// The type of resource.
	ResourceType ResourceType
}

type ReplaceDefaultPolicyVersionParams struct {
	// The name of the template to be applied. The only supported value is
	// BLANK_POLICY.
	TemplateName PolicyTemplateName
}

type ReportType string

const (
	ReportTypeErrors  ReportType = "ERRORS"
	ReportTypeResults ReportType = "RESULTS"
)

type RepublishAction struct {
	// The ARN of the IAM role that grants access.
	RoleArn *string
	// The Quality of Service (QoS) level to use when republishing messages. The
	// default value is 0.
	Qos *int32
	// The name of the MQTT topic.
	Topic *string
}

type ResourceAlreadyExistsException struct {
	Message *string

	ResourceId  *string
	ResourceArn *string
}

type ResourceIdentifier struct {
	// The version of the policy associated with the resource.
	PolicyVersionIdentifier *PolicyVersionIdentifier
	// The account with which the resource is associated.
	Account *string
	// The ID of the certificate attached to the resource.
	DeviceCertificateId *string
	// The ARN of the IAM role that has overly permissive actions.
	IamRoleArn *string
	// The ARN of the role alias that has overly permissive actions.
	RoleAliasArn *string
	// The client ID.
	ClientId *string
	// The ID of the CA certificate used to authorize the certificate.
	CaCertificateId *string
	// The ID of the Amazon Cognito identity pool.
	CognitoIdentityPoolId *string
}

type ResourceNotFoundException struct {
	Message *string
}

type ResourceRegistrationFailureException struct {
	Message *string
}

type ResourceType string

const (
	ResourceTypeDevice_certificate    ResourceType = "DEVICE_CERTIFICATE"
	ResourceTypeCa_certificate        ResourceType = "CA_CERTIFICATE"
	ResourceTypeIot_policy            ResourceType = "IOT_POLICY"
	ResourceTypeCognito_identity_pool ResourceType = "COGNITO_IDENTITY_POOL"
	ResourceTypeClient_id             ResourceType = "CLIENT_ID"
	ResourceTypeAccount_settings      ResourceType = "ACCOUNT_SETTINGS"
	ResourceTypeRole_alias            ResourceType = "ROLE_ALIAS"
	ResourceTypeIam_role              ResourceType = "IAM_ROLE"
)

type RoleAliasDescription struct {
	// The role ARN.
	RoleArn *string
	// The UNIX timestamp of when the role alias was last modified.
	LastModifiedDate *time.Time
	// The role alias owner.
	Owner *string
	// The role alias.
	RoleAlias *string
	// The number of seconds for which the credential is valid.
	CredentialDurationSeconds *int32
	// The UNIX timestamp of when the role alias was created.
	CreationDate *time.Time
	// The ARN of the role alias.
	RoleAliasArn *string
}

type S3Action struct {
	// The object key.
	Key *string
	// The ARN of the IAM role that grants access.
	RoleArn *string
	// The Amazon S3 canned ACL that controls access to the object identified by the
	// object key. For more information, see S3 canned ACLs
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl).
	CannedAcl CannedAccessControlList
	// The Amazon S3 bucket.
	BucketName *string
}

type S3Destination struct {
	// The S3 prefix.
	Prefix *string
	// The S3 bucket that contains the updated firmware.
	Bucket *string
}

type S3Location struct {
	// The S3 bucket.
	Bucket *string
	// The S3 bucket version.
	Version *string
	// The S3 key.
	Key *string
}

type SalesforceAction struct {
	// The token used to authenticate access to the Salesforce IoT Cloud Input Stream.
	// The token is available from the Salesforce IoT Cloud platform after creation of
	// the Input Stream.
	Token *string
	// The URL exposed by the Salesforce IoT Cloud Input Stream. The URL is available
	// from the Salesforce IoT Cloud platform after creation of the Input Stream.
	Url *string
}

type ScheduledAuditMetadata struct {
	// The day of the month on which the scheduled audit is run (if the frequency is
	// "MONTHLY"). If days 29-31 are specified, and the month does not have that many
	// days, the audit takes place on the "LAST" day of the month.
	DayOfMonth *string
	// The day of the week on which the scheduled audit is run (if the frequency is
	// "WEEKLY" or "BIWEEKLY").
	DayOfWeek DayOfWeek
	// The ARN of the scheduled audit.
	ScheduledAuditArn *string
	// The name of the scheduled audit.
	ScheduledAuditName *string
	// How often the scheduled audit occurs.
	Frequency AuditFrequency
}

type SecurityProfileIdentifier struct {
	// The ARN of the security profile.
	Arn *string
	// The name you have given to the security profile.
	Name *string
}

type SecurityProfileTarget struct {
	// The ARN of the security profile.
	Arn *string
}

type SecurityProfileTargetMapping struct {
	// Information about the target (thing group) associated with the security profile.
	Target *SecurityProfileTarget
	// Information that identifies the security profile.
	SecurityProfileIdentifier *SecurityProfileIdentifier
}

type ServerCertificateStatus string

const (
	ServerCertificateStatusInvalid ServerCertificateStatus = "INVALID"
	ServerCertificateStatusValid   ServerCertificateStatus = "VALID"
)

type ServerCertificateSummary struct {
	// Details that explain the status of the server certificate.
	ServerCertificateStatusDetail *string
	// The status of the server certificate.
	ServerCertificateStatus ServerCertificateStatus
	// The ARN of the server certificate.
	ServerCertificateArn *string
}

type ServiceType string

const (
	ServiceTypeData                ServiceType = "DATA"
	ServiceTypeCredential_provider ServiceType = "CREDENTIAL_PROVIDER"
	ServiceTypeJobs                ServiceType = "JOBS"
)

type ServiceUnavailableException struct {
	Message *string
}

type SigV4Authorization struct {
	// The service name to use while signing with Sig V4.
	ServiceName *string
	// The signing region.
	SigningRegion *string
	// The ARN of the signing role.
	RoleArn *string
}

type SigningProfileParameter struct {
	// Certificate ARN.
	CertificateArn *string
	// The location of the code-signing certificate on your device.
	CertificatePathOnDevice *string
	// The hardware platform of your device.
	Platform *string
}

type SnsAction struct {
	// The ARN of the IAM role that grants access.
	RoleArn *string
	// (Optional) The message format of the message to publish. Accepted values are
	// "JSON" and "RAW". The default value of the attribute is "RAW". SNS uses this
	// setting to determine if the payload should be parsed and relevant
	// platform-specific bits of the payload should be extracted. To read more about
	// SNS message formats, see
	// https://docs.aws.amazon.com/sns/latest/dg/json-formats.html
	// (https://docs.aws.amazon.com/sns/latest/dg/json-formats.html) refer to their
	// official documentation.
	MessageFormat MessageFormat
	// The ARN of the SNS topic.
	TargetArn *string
}

type SqlParseException struct {
	Message *string
}

type SqsAction struct {
	// The ARN of the IAM role that grants access.
	RoleArn *string
	// Specifies whether to use Base64 encoding.
	UseBase64 *bool
	// The URL of the Amazon SQS queue.
	QueueUrl *string
}

type StartSigningJobParameter struct {
	// Describes the code-signing profile.
	SigningProfileParameter *SigningProfileParameter
	// The code-signing profile name.
	SigningProfileName *string
	// The location to write the code-signed file.
	Destination *Destination
}

type StatisticalThreshold struct {
	// The percentile which resolves to a threshold value by which compliance with a
	// behavior is determined. Metrics are collected over the specified period
	// (durationSeconds) from all reporting devices in your account and statistical
	// ranks are calculated. Then, the measurements from a device are collected over
	// the same period. If the accumulated measurements from the device fall above or
	// below (comparisonOperator) the value associated with the percentile specified,
	// then the device is considered to be in compliance with the behavior, otherwise a
	// violation occurs.
	Statistic *string
}

type Statistics struct {
	// The maximum aggregated field value.
	Maximum *float64
	// The count of things that match the query.
	Count *int32
	// The standard deviation of the aggregated field values.
	StdDeviation *float64
	// The sum of the aggregated field values.
	Sum *float64
	// The sum of the squares of the aggregated field values.
	SumOfSquares *float64
	// The average of the aggregated field values.
	Average *float64
	// The minimum aggregated field value.
	Minimum *float64
	// The variance of the aggregated field values.
	Variance *float64
}

type Status string

const (
	StatusInprogress Status = "InProgress"
	StatusCompleted  Status = "Completed"
	StatusFailed     Status = "Failed"
	StatusCancelled  Status = "Cancelled"
	StatusCancelling Status = "Cancelling"
)

type StepFunctionsAction struct {
	// (Optional) A name will be given to the state machine execution consisting of
	// this prefix followed by a UUID. Step Functions automatically creates a unique
	// name for each state machine execution if one is not provided.
	ExecutionNamePrefix *string
	// The ARN of the role that grants IoT permission to start execution of a state
	// machine ("Action":"states:StartExecution").
	RoleArn *string
	// The name of the Step Functions state machine whose execution will be started.
	StateMachineName *string
}

type Stream struct {
	// The ID of a file associated with a stream.
	FileId *int32
	// The stream ID.
	StreamId *string
}

type StreamFile struct {
	// The file ID.
	FileId *int32
	// The location of the file in S3.
	S3Location *S3Location
}

type StreamInfo struct {
	// The date when the stream was last updated.
	LastUpdatedAt *time.Time
	// The files to stream.
	Files []*StreamFile
	// The stream ID.
	StreamId *string
	// An IAM role AWS IoT assumes to access your S3 files.
	RoleArn *string
	// The date when the stream was created.
	CreatedAt *time.Time
	// The stream ARN.
	StreamArn *string
	// The description of the stream.
	Description *string
	// The stream version.
	StreamVersion *int32
}

type StreamSummary struct {
	// The stream ID.
	StreamId *string
	// A description of the stream.
	Description *string
	// The stream ARN.
	StreamArn *string
	// The stream version.
	StreamVersion *int32
}

type Tag struct {
	// The tag's key.
	Key *string
	// The tag's value.
	Value *string
}

type TargetSelection string

const (
	TargetSelectionContinuous TargetSelection = "CONTINUOUS"
	TargetSelectionSnapshot   TargetSelection = "SNAPSHOT"
)

type TaskAlreadyExistsException struct {
	Message *string
}

type TaskStatistics struct {
	// The number of checks in this audit.
	TotalChecks *int32
	// The number of checks that found compliant resources.
	CompliantChecks *int32
	// The number of checks that found noncompliant resources.
	NonCompliantChecks *int32
	// The number of checks.
	FailedChecks *int32
	// The number of checks waiting for data collection.
	WaitingForDataCollectionChecks *int32
	// The number of checks in progress.
	InProgressChecks *int32
	// The number of checks that did not run because the audit was canceled.
	CanceledChecks *int32
}

type TaskStatisticsForAuditCheck struct {
	// The number of findings for which at least one of the actions failed when
	// applied.
	FailedFindingsCount *int64
	// The number of findings to which the mitigation action task was canceled when
	// applied.
	CanceledFindingsCount *int64
	// The number of findings for which all mitigation actions succeeded when applied.
	SucceededFindingsCount *int64
	// The number of findings skipped because of filter conditions provided in the
	// parameters to the command.
	SkippedFindingsCount *int64
	// The total number of findings to which a task is being applied.
	TotalFindingsCount *int64
}

type ThingAttribute struct {
	// The version of the thing record in the registry.
	Version *int64
	// The name of the thing.
	ThingName *string
	// The name of the thing type, if the thing has been associated with a type.
	ThingTypeName *string
	// The thing ARN.
	ThingArn *string
	// A list of thing attributes which are name-value pairs.
	Attributes map[string]*string
}

type ThingConnectivity struct {
	// True if the thing is connected to the AWS IoT service; false if it is not
	// connected.
	Connected *bool
	// The epoch time (in milliseconds) when the thing last connected or disconnected.
	// If the thing has been disconnected for more than a few weeks, the time value
	// might be missing.
	Timestamp *int64
}

type ThingConnectivityIndexingMode string

const (
	ThingConnectivityIndexingModeOff    ThingConnectivityIndexingMode = "OFF"
	ThingConnectivityIndexingModeStatus ThingConnectivityIndexingMode = "STATUS"
)

type ThingDocument struct {
	// Thing group names.
	ThingGroupNames []*string
	// The shadow.
	Shadow *string
	// Indicates whether the thing is connected to the AWS IoT service.
	Connectivity *ThingConnectivity
	// The thing type name.
	ThingTypeName *string
	// The thing name.
	ThingName *string
	// The attributes.
	Attributes map[string]*string
	// The thing ID.
	ThingId *string
}

type ThingGroupDocument struct {
	// The thing group ID.
	ThingGroupId *string
	// The thing group attributes.
	Attributes map[string]*string
	// The thing group description.
	ThingGroupDescription *string
	// Parent group names.
	ParentGroupNames []*string
	// The thing group name.
	ThingGroupName *string
}

type ThingGroupIndexingConfiguration struct {
	// Contains fields that are indexed and whose types are already known by the Fleet
	// Indexing service.
	ManagedFields []*Field
	// A list of thing group fields to index. This list cannot contain any managed
	// fields. Use the GetIndexingConfiguration API to get a list of managed fields.
	// Contains custom field names and their data type.
	CustomFields []*Field
	// Thing group indexing mode.
	ThingGroupIndexingMode ThingGroupIndexingMode
}

type ThingGroupIndexingMode string

const (
	ThingGroupIndexingModeOff ThingGroupIndexingMode = "OFF"
	ThingGroupIndexingModeOn  ThingGroupIndexingMode = "ON"
)

type ThingGroupMetadata struct {
	// The UNIX timestamp of when the thing group was created.
	CreationDate *time.Time
	// The parent thing group name.
	ParentGroupName *string
	// The root parent thing group.
	RootToParentThingGroups []*GroupNameAndArn
}

type ThingGroupProperties struct {
	// The thing group description.
	ThingGroupDescription *string
	// The thing group attributes in JSON format.
	AttributePayload *AttributePayload
}

type ThingIndexingConfiguration struct {
	// Contains fields that are indexed and whose types are already known by the Fleet
	// Indexing service.
	ManagedFields []*Field
	// Thing indexing mode. Valid values are:
	//
	//     * REGISTRY – Your thing index
	// contains registry data only.
	//
	//     * REGISTRY_AND_SHADOW - Your thing index
	// contains registry and shadow data.
	//
	//     * OFF - Thing indexing is disabled.
	ThingIndexingMode ThingIndexingMode
	// Thing connectivity indexing mode. Valid values are:
	//
	//     * STATUS – Your thing
	// index contains connectivity status. To enable thing connectivity indexing,
	// thingIndexMode must not be set to OFF.
	//
	//     * OFF - Thing connectivity status
	// indexing is disabled.
	ThingConnectivityIndexingMode ThingConnectivityIndexingMode
	// Contains custom field names and their data type.
	CustomFields []*Field
}

type ThingIndexingMode string

const (
	ThingIndexingModeOff                 ThingIndexingMode = "OFF"
	ThingIndexingModeRegistry            ThingIndexingMode = "REGISTRY"
	ThingIndexingModeRegistry_and_shadow ThingIndexingMode = "REGISTRY_AND_SHADOW"
)

type ThingTypeDefinition struct {
	// The name of the thing type.
	ThingTypeName *string
	// The ThingTypeMetadata contains additional information about the thing type
	// including: creation date and time, a value indicating whether the thing type is
	// deprecated, and a date and time when it was deprecated.
	ThingTypeMetadata *ThingTypeMetadata
	// The thing type ARN.
	ThingTypeArn *string
	// The ThingTypeProperties for the thing type.
	ThingTypeProperties *ThingTypeProperties
}

type ThingTypeMetadata struct {
	// Whether the thing type is deprecated. If true, no new things could be associated
	// with this type.
	Deprecated *bool
	// The date and time when the thing type was created.
	CreationDate *time.Time
	// The date and time when the thing type was deprecated.
	DeprecationDate *time.Time
}

type ThingTypeProperties struct {
	// The description of the thing type.
	ThingTypeDescription *string
	// A list of searchable thing attribute names.
	SearchableAttributes []*string
}

type ThrottlingException struct {
	Message *string
}

type TimeoutConfig struct {
	// Specifies the amount of time, in minutes, this device has to finish execution of
	// this job. The timeout interval can be anywhere between 1 minute and 7 days (1 to
	// 10080 minutes). The in progress timer can't be updated and will apply to all job
	// executions for the job. Whenever a job execution remains in the IN_PROGRESS
	// status for longer than this interval, the job execution will fail and switch to
	// the terminal TIMED_OUT status.
	InProgressTimeoutInMinutes *int64
}

type TlsContext struct {
	// The value of the serverName key in a TLS authorization request.
	ServerName *string
}

type TopicRule struct {
	// Specifies whether the rule is disabled.
	RuleDisabled *bool
	// The SQL statement used to query the topic. When using a SQL query with multiple
	// lines, be sure to escape the newline characters.
	Sql *string
	// The actions associated with the rule.
	Actions []*Action
	// The description of the rule.
	Description *string
	// The date and time the rule was created.
	CreatedAt *time.Time
	// The action to perform when an error occurs.
	ErrorAction *Action
	// The name of the rule.
	RuleName *string
	// The version of the SQL rules engine to use when evaluating the rule.
	AwsIotSqlVersion *string
}

type TopicRuleDestination struct {
	// The topic rule destination URL.
	Arn *string
	// Additional details or reason why the topic rule destination is in the current
	// status.
	StatusReason *string
	// The status of the topic rule destination. Valid values are: IN_PROGRESS A topic
	// rule destination was created but has not been confirmed. You can set status to
	// IN_PROGRESS by calling UpdateTopicRuleDestination. Calling
	// UpdateTopicRuleDestination causes a new confirmation challenge to be sent to
	// your confirmation endpoint. ENABLED Confirmation was completed, and traffic to
	// this destination is allowed. You can set status to DISABLED by calling
	// UpdateTopicRuleDestination. DISABLED Confirmation was completed, and traffic to
	// this destination is not allowed. You can set status to ENABLED by calling
	// UpdateTopicRuleDestination. ERROR Confirmation could not be completed, for
	// example if the confirmation timed out. You can call GetTopicRuleDestination for
	// details about the error. You can set status to IN_PROGRESS by calling
	// UpdateTopicRuleDestination. Calling UpdateTopicRuleDestination causes a new
	// confirmation challenge to be sent to your confirmation endpoint.
	Status TopicRuleDestinationStatus
	// Properties of the HTTP URL.
	HttpUrlProperties *HttpUrlDestinationProperties
}

type TopicRuleDestinationConfiguration struct {
	// Configuration of the HTTP URL.
	HttpUrlConfiguration *HttpUrlDestinationConfiguration
}

type TopicRuleDestinationStatus string

const (
	TopicRuleDestinationStatusEnabled     TopicRuleDestinationStatus = "ENABLED"
	TopicRuleDestinationStatusIn_progress TopicRuleDestinationStatus = "IN_PROGRESS"
	TopicRuleDestinationStatusDisabled    TopicRuleDestinationStatus = "DISABLED"
	TopicRuleDestinationStatusError       TopicRuleDestinationStatus = "ERROR"
)

type TopicRuleDestinationSummary struct {
	// The status of the topic rule destination. Valid values are: IN_PROGRESS A topic
	// rule destination was created but has not been confirmed. You can set status to
	// IN_PROGRESS by calling UpdateTopicRuleDestination. Calling
	// UpdateTopicRuleDestination causes a new confirmation challenge to be sent to
	// your confirmation endpoint. ENABLED Confirmation was completed, and traffic to
	// this destination is allowed. You can set status to DISABLED by calling
	// UpdateTopicRuleDestination. DISABLED Confirmation was completed, and traffic to
	// this destination is not allowed. You can set status to ENABLED by calling
	// UpdateTopicRuleDestination. ERROR Confirmation could not be completed, for
	// example if the confirmation timed out. You can call GetTopicRuleDestination for
	// details about the error. You can set status to IN_PROGRESS by calling
	// UpdateTopicRuleDestination. Calling UpdateTopicRuleDestination causes a new
	// confirmation challenge to be sent to your confirmation endpoint.
	Status TopicRuleDestinationStatus
	// The topic rule destination ARN.
	Arn *string
	// Information about the HTTP URL.
	HttpUrlSummary *HttpUrlDestinationSummary
	// The reason the topic rule destination is in the current status.
	StatusReason *string
}

type TopicRuleListItem struct {
	// Specifies whether the rule is disabled.
	RuleDisabled *bool
	// The name of the rule.
	RuleName *string
	// The date and time the rule was created.
	CreatedAt *time.Time
	// The pattern for the topic names that apply.
	TopicPattern *string
	// The rule ARN.
	RuleArn *string
}

type TopicRulePayload struct {
	// The SQL statement used to query the topic. For more information, see AWS IoT SQL
	// Reference
	// (https://docs.aws.amazon.com/iot/latest/developerguide/iot-rules.html#aws-iot-sql-reference)
	// in the AWS IoT Developer Guide.
	Sql *string
	// The version of the SQL rules engine to use when evaluating the rule.
	AwsIotSqlVersion *string
	// Specifies whether the rule is disabled.
	RuleDisabled *bool
	// The actions associated with the rule.
	Actions []*Action
	// The action to take when an error occurs.
	ErrorAction *Action
	// The description of the rule.
	Description *string
}

type TransferAlreadyCompletedException struct {
	Message *string
}

type TransferConflictException struct {
	Message *string
}

type TransferData struct {
	// The date the transfer took place.
	TransferDate *time.Time
	// The date the transfer was rejected.
	RejectDate *time.Time
	// The reason why the transfer was rejected.
	RejectReason *string
	// The date the transfer was accepted.
	AcceptDate *time.Time
	// The transfer message.
	TransferMessage *string
}

type UnauthorizedException struct {
	Message *string
}

type UpdateCACertificateParams struct {
	// The action that you want to apply to the CA cerrtificate. The only supported
	// value is DEACTIVATE.
	Action CACertificateUpdateAction
}

type UpdateDeviceCertificateParams struct {
	// The action that you want to apply to the device cerrtificate. The only supported
	// value is DEACTIVATE.
	Action DeviceCertificateUpdateAction
}

type ValidationError struct {
	// The description of an error found in the behaviors.
	ErrorMessage *string
}

type VersionConflictException struct {
	Message *string
}

type VersionsLimitExceededException struct {
	Message *string
}

type ViolationEvent struct {
	// The time the violation event occurred.
	ViolationEventTime *time.Time
	// The ID of the violation event.
	ViolationId *string
	// The behavior which was violated.
	Behavior *Behavior
	// The value of the metric (the measurement).
	MetricValue *MetricValue
	// The name of the security profile whose behavior was violated.
	SecurityProfileName *string
	// The name of the thing responsible for the violation event.
	ThingName *string
	// The type of violation event.
	ViolationEventType ViolationEventType
}

type ViolationEventType string

const (
	ViolationEventTypeIn_alarm          ViolationEventType = "in-alarm"
	ViolationEventTypeAlarm_cleared     ViolationEventType = "alarm-cleared"
	ViolationEventTypeAlarm_invalidated ViolationEventType = "alarm-invalidated"
)