types

package
v0.26.0 Latest Latest
Warning

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

 Go to latest Published: Oct 1, 2020 License: Apache-2.0 Imports: 3 Imported by: 9

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AbortAction 

type AbortAction string
const (
	AbortActionCancel AbortAction = "CANCEL"
)

Enum values for AbortAction

type AbortConfig 

type AbortConfig struct {

	// The list of criteria that determine when and how to abort the job.
	//
	// This member is required.
	CriteriaList []*AbortCriteria
}

The criteria that determine when and how a job abort takes place.

type AbortCriteria 

type AbortCriteria struct {

	// The type of job action to take to initiate the job abort.
	//
	// This member is required.
	Action AbortAction

	// The minimum number of things which must receive job execution notifications
	// before the job can be aborted.
	//
	// This member is required.
	MinNumberOfExecutedThings *int32

	// The type of job execution failures that can initiate a job abort.
	//
	// This member is required.
	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).
	//
	// This member is required.
	ThresholdPercentage *float64
}

The criteria that determine when and how a job abort takes place.

type Action 

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
}

Describes the actions associated with a rule.

type ActionType 

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

Enum values for ActionType

type ActiveViolation 

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
}

Information about an active Device Defender security profile behavior violation.

type AddThingsToThingGroupParams 

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.
	//
	// This member is required.
	ThingGroupNames []*string
}

Parameters used when defining a mitigation action that move a set of things to a thing group.

type AlertTarget 

type AlertTarget struct {

	// The ARN of the notification target to which alerts are sent.
	//
	// This member is required.
	AlertTargetArn *string

	// The ARN of the role that grants permission to send alerts to the notification
	// target.
	//
	// This member is required.
	RoleArn *string
}

A structure containing the alert target ARN and the role ARN.

type AlertTargetType 

type AlertTargetType string
const (
	AlertTargetTypeSns AlertTargetType = "SNS"
)

Enum values for AlertTargetType

type Allowed 

type Allowed struct {

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

Contains information that allowed the authorization.

type AssetPropertyTimestamp 

type AssetPropertyTimestamp struct {

	// A string that contains the time in seconds since epoch. Accepts substitution
	// templates.
	//
	// This member is required.
	TimeInSeconds *string

	// Optional. A string that contains the nanosecond time offset. Accepts
	// substitution templates.
	OffsetInNanos *string
}

An asset property timestamp entry containing the following information.

type AssetPropertyValue 

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.
	//
	// This member is required.
	Timestamp *AssetPropertyTimestamp

	// The value of the asset property.
	//
	// This member is required.
	Value *AssetPropertyVariant
}

An asset property value entry containing the following information.

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

Contains an asset property value (of a single type).

type AttributePayload 

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
}

The attribute payload.

type AuditCheckConfiguration 

type AuditCheckConfiguration struct {

	// True if this audit check is enabled for this account.
	Enabled *bool
}

Which audit checks are enabled and disabled for this account.

type AuditCheckDetails 

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
}

Information about the audit check.

type AuditCheckRunStatus 

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

Enum values for AuditCheckRunStatus

type AuditFinding 

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
}

The findings (results) of the audit.

type AuditFindingSeverity 

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

Enum values for AuditFindingSeverity

type AuditFrequency 

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

Enum values for AuditFrequency

type AuditMitigationActionExecutionMetadata 

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
}

Returned by ListAuditMitigationActionsTask, this object contains information that describes a mitigation action that has been started.

type AuditMitigationActionsExecutionStatus 

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

Enum values for AuditMitigationActionsExecutionStatus

type AuditMitigationActionsTaskMetadata 

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
}

Information about an audit mitigation actions task that is returned by ListAuditMitigationActionsTasks.

type AuditMitigationActionsTaskStatus 

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

Enum values for AuditMitigationActionsTaskStatus

type AuditMitigationActionsTaskTarget 

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
}

Used in MitigationActionParams, this information identifies the target findings to which the mitigation actions are applied. Only one entry appears.

type AuditNotificationTarget 

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
}

Information about the targets to which audit notifications are sent.

type AuditNotificationType 

type AuditNotificationType string
const (
	AuditNotificationTypeSns AuditNotificationType = "SNS"
)

Enum values for AuditNotificationType

type AuditTaskMetadata 

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
}

The audits that were performed.

type AuditTaskStatus 

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

Enum values for AuditTaskStatus

type AuditTaskType 

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

Enum values for AuditTaskType

type AuthDecision 

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

Enum values for AuthDecision

type AuthInfo 

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.
	//
	// This member is required.
	Resources []*string
}

A collection of authorization information.

type AuthResult 

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
}

The authorizer result.

type AuthorizerConfig 

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
}

An object that specifies the authorization service for a domain.

type AuthorizerDescription 

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
}

The authorizer description.

type AuthorizerStatus 

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

Enum values for AuthorizerStatus

type AuthorizerSummary 

type AuthorizerSummary struct {

	// The authorizer ARN.
	AuthorizerArn *string

	// The authorizer name.
	AuthorizerName *string
}

The authorizer summary.

type AutoRegistrationStatus 

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

Enum values for AutoRegistrationStatus

type AwsJobAbortConfig 

type AwsJobAbortConfig struct {

	// The list of criteria that determine when and how to abort the job.
	//
	// This member is required.
	AbortCriteriaList []*AwsJobAbortCriteria
}

The criteria that determine when and how a job abort takes place.

type AwsJobAbortCriteria 

type AwsJobAbortCriteria struct {

	// The type of job action to take to initiate the job abort.
	//
	// This member is required.
	Action AwsJobAbortCriteriaAbortAction

	// The type of job execution failures that can initiate a job abort.
	//
	// This member is required.
	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).
	//
	// This member is required.
	ThresholdPercentage *float64

	// The minimum number of things which must receive job execution notifications
	// before the job can be aborted.
	//
	// This member is required.
	MinNumberOfExecutedThings *int32
}

The criteria that determine when and how a job abort takes place.

type AwsJobAbortCriteriaAbortAction 

type AwsJobAbortCriteriaAbortAction string
const (
	AwsJobAbortCriteriaAbortActionCancel AwsJobAbortCriteriaAbortAction = "CANCEL"
)

Enum values for AwsJobAbortCriteriaAbortAction

type AwsJobAbortCriteriaFailureType 

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

Enum values for AwsJobAbortCriteriaFailureType

type AwsJobExecutionsRolloutConfig 

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
}

Configuration for the rollout of OTA updates.

type 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).
	//
	// This member is required.
	RateIncreaseCriteria *AwsJobRateIncreaseCriteria

	// The rate of increase for a job rollout. The number of things notified is
	// multiplied by this factor.
	//
	// This member is required.
	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.
	//
	// This member is required.
	BaseRatePerMinute *int32
}

The rate of increase for a job rollout. This parameter allows you to define an exponential rate increase for a job rollout.

type AwsJobPresignedUrlConfig 

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
}

Configuration information for pre-signed URLs. Valid when protocols contains HTTP.

type AwsJobRateIncreaseCriteria 

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
}

The criteria to initiate the increase in rate of rollout for a job.

type AwsJobTimeoutConfig 

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
}

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.

type Behavior 

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.
	//
	// This member is required.
	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
}

A Device Defender security profile behavior.

type BehaviorCriteria 

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
}

The criteria by which the behavior is determined to be normal.

type BillingGroupMetadata 

type BillingGroupMetadata struct {

	// The date the billing group was created.
	CreationDate *time.Time
}

Additional information about the billing group.

type BillingGroupProperties 

type BillingGroupProperties struct {

	// The description of the billing group.
	BillingGroupDescription *string
}

The properties of a billing group.

type CACertificate 

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
}

A CA certificate.

type CACertificateDescription 

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
}

Describes a CA certificate.

type CACertificateStatus 

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

Enum values for CACertificateStatus

type CACertificateUpdateAction 

type CACertificateUpdateAction string
const (
	CACertificateUpdateActionDeactivate CACertificateUpdateAction = "DEACTIVATE"
)

Enum values for CACertificateUpdateAction

type CannedAccessControlList 

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

Enum values for CannedAccessControlList

type Certificate 

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
}

Information about a certificate.

type CertificateConflictException 

type CertificateConflictException struct {
	Message *string
}

Unable to verify the CA certificate used to sign the device certificate you are attempting to register. This is happens when you have registered more than one CA certificate that has the same subject field and public key.

func (*CertificateConflictException) Error 

func (e *CertificateConflictException) Error() string

func (*CertificateConflictException) ErrorCode 

func (e *CertificateConflictException) ErrorCode() string

func (*CertificateConflictException) ErrorFault 

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

func (*CertificateConflictException) ErrorMessage 

func (e *CertificateConflictException) ErrorMessage() string

type CertificateDescription 

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
}

Describes a certificate.

type CertificateMode 

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

Enum values for CertificateMode

type CertificateStateException 

type CertificateStateException struct {
	Message *string
}

The certificate operation is not allowed.

func (*CertificateStateException) Error 

func (e *CertificateStateException) Error() string

func (*CertificateStateException) ErrorCode 

func (e *CertificateStateException) ErrorCode() string

func (*CertificateStateException) ErrorFault 

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

func (*CertificateStateException) ErrorMessage 

func (e *CertificateStateException) ErrorMessage() string

type CertificateStatus 

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

Enum values for CertificateStatus

type CertificateValidationException 

type CertificateValidationException struct {
	Message *string
}

The certificate is invalid.

func (*CertificateValidationException) Error 

func (e *CertificateValidationException) Error() string

func (*CertificateValidationException) ErrorCode 

func (e *CertificateValidationException) ErrorCode() string

func (*CertificateValidationException) ErrorFault 

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

func (*CertificateValidationException) ErrorMessage 

func (e *CertificateValidationException) ErrorMessage() string

type CertificateValidity 

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
}

When the certificate is valid.

type CloudwatchAlarmAction 

type CloudwatchAlarmAction struct {

	// The CloudWatch alarm name.
	//
	// This member is required.
	AlarmName *string

	// The IAM role that allows access to the CloudWatch alarm.
	//
	// This member is required.
	RoleArn *string

	// The reason for the alarm change.
	//
	// This member is required.
	StateReason *string

	// The value of the alarm state. Acceptable values are: OK, ALARM,
	// INSUFFICIENT_DATA.
	//
	// This member is required.
	StateValue *string
}

Describes an action that updates a CloudWatch alarm.

type CloudwatchLogsAction 

type CloudwatchLogsAction struct {

	// The IAM role that allows access to the CloudWatch log.
	//
	// This member is required.
	RoleArn *string

	// The CloudWatch log group to which the action sends data.
	//
	// This member is required.
	LogGroupName *string
}

Describes an action that sends data to CloudWatch Logs.

type CloudwatchMetricAction 

type CloudwatchMetricAction struct {

	// The CloudWatch metric namespace name.
	//
	// This member is required.
	MetricNamespace *string

	// The metric unit
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#Unit)
	// supported by CloudWatch.
	//
	// This member is required.
	MetricUnit *string

	// The CloudWatch metric name.
	//
	// This member is required.
	MetricName *string

	// The IAM role that allows access to the CloudWatch metric.
	//
	// This member is required.
	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.
	//
	// This member is required.
	MetricValue *string
}

Describes an action that captures a CloudWatch metric.

type CodeSigning 

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
}

Describes the method to use when code signing a file.

type CodeSigningCertificateChain 

type CodeSigningCertificateChain struct {

	// The name of the certificate.
	CertificateName *string

	// A base64 encoded binary representation of the code signing certificate chain.
	InlineDocument *string
}

Describes the certificate chain being used when code signing a file.

type CodeSigningSignature 

type CodeSigningSignature struct {

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

Describes the signature for a file.

type ComparisonOperator 

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

Enum values for ComparisonOperator

type Configuration 

type Configuration struct {

	// True to enable the configuration.
	Enabled *bool
}

Configuration.

type ConflictingResourceUpdateException 

type ConflictingResourceUpdateException struct {
	Message *string
}

A conflicting resource update exception. This exception is thrown when two pending updates cause a conflict.

func (*ConflictingResourceUpdateException) Error 

func (e *ConflictingResourceUpdateException) Error() string

func (*ConflictingResourceUpdateException) ErrorCode 

func (e *ConflictingResourceUpdateException) ErrorCode() string

func (*ConflictingResourceUpdateException) ErrorFault 

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

func (*ConflictingResourceUpdateException) ErrorMessage 

func (e *ConflictingResourceUpdateException) ErrorMessage() string

type CustomCodeSigning 

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
}

Describes a custom method used to code sign a file.

type DayOfWeek 

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

Enum values for DayOfWeek

type DeleteConflictException 

type DeleteConflictException struct {
	Message *string
}

You can't delete the resource because it is attached to one or more resources.

func (*DeleteConflictException) Error 

func (e *DeleteConflictException) Error() string

func (*DeleteConflictException) ErrorCode 

func (e *DeleteConflictException) ErrorCode() string

func (*DeleteConflictException) ErrorFault 

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

func (*DeleteConflictException) ErrorMessage 

func (e *DeleteConflictException) ErrorMessage() string

type Denied 

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
}

Contains information that denied the authorization.

type Destination 

type Destination struct {

	// Describes the location in S3 of the updated firmware.
	S3Destination *S3Destination
}

Describes the location of the updated firmware.

type DeviceCertificateUpdateAction 

type DeviceCertificateUpdateAction string
const (
	DeviceCertificateUpdateActionDeactivate DeviceCertificateUpdateAction = "DEACTIVATE"
)

Enum values for DeviceCertificateUpdateAction

type DimensionType 

type DimensionType string
const (
	DimensionTypeTopic_filter DimensionType = "TOPIC_FILTER"
)

Enum values for DimensionType

type DimensionValueOperator 

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

Enum values for DimensionValueOperator

type DomainConfigurationStatus 

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

Enum values for DomainConfigurationStatus

type DomainConfigurationSummary 

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
}

The summary of a domain configuration. A domain configuration specifies custom IoT-specific information about a domain. A domain configuration can be associated with an AWS-managed domain (for example, dbc123defghijk.iot.us-west-2.amazonaws.com), a customer managed domain, or a default endpoint.

  • Data

  • Jobs

  • CredentialProvider

The domain configuration feature is in public preview and is subject to change.

type DomainType 

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

Enum values for DomainType

type DynamicGroupStatus 

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

Enum values for DynamicGroupStatus

type DynamoDBAction 

type DynamoDBAction struct {

	// The hash key value.
	//
	// This member is required.
	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.
	//
	// This member is required.
	RoleArn *string

	// The action payload. This name can be customized.
	PayloadField *string

	// The name of the DynamoDB table.
	//
	// This member is required.
	TableName *string

	// The hash key type. Valid values are "STRING" or "NUMBER"
	HashKeyType DynamoKeyType

	// The hash key name.
	//
	// This member is required.
	HashKeyField *string

	// The range key value.
	RangeKeyValue *string

	// The range key type. Valid values are "STRING" or "NUMBER"
	RangeKeyType DynamoKeyType
}

Describes an action to write to a DynamoDB table. The tableName, hashKeyField, and rangeKeyField values must match the values used when you created the table. The hashKeyValue and rangeKeyvalue fields use a substitution template syntax. These templates provide data at runtime. The syntax is as follows: ${sql-expression}. You can specify any valid expression in a WHERE or SELECT clause, including JSON properties, comparisons, calculations, and functions. For example, the following field uses the third level of the topic: "hashKeyValue": "${topic(3)}" The following field uses the timestamp: "rangeKeyValue": "${timestamp()}"

type DynamoDBv2Action 

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.
	//
	// This member is required.
	PutItem *PutItemInput

	// The ARN of the IAM role that grants access to the DynamoDB table.
	//
	// This member is required.
	RoleArn *string
}

Describes an action to write to a DynamoDB table. This DynamoDB action writes each attribute in the message payload into it's own column in the DynamoDB table.

type DynamoKeyType 

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

Enum values for DynamoKeyType

type EffectivePolicy 

type EffectivePolicy struct {

	// The policy name.
	PolicyName *string

	// The policy ARN.
	PolicyArn *string

	// The IAM policy document.
	PolicyDocument *string
}

The policy that has the effect on the authorization results.

type ElasticsearchAction 

type ElasticsearchAction struct {

	// The Elasticsearch index where you want to store your data.
	//
	// This member is required.
	Index *string

	// The endpoint of your Elasticsearch domain.
	//
	// This member is required.
	Endpoint *string

	// The unique identifier for the document you are storing.
	//
	// This member is required.
	Id *string

	// The type of document you are storing.
	//
	// This member is required.
	Type *string

	// The IAM role ARN that has access to Elasticsearch.
	//
	// This member is required.
	RoleArn *string
}

Describes an action that writes data to an Amazon Elasticsearch Service domain.

type EnableIoTLoggingParams 

type EnableIoTLoggingParams struct {

	// The ARN of the IAM role used for logging.
	//
	// This member is required.
	RoleArnForLogging *string

	// Specifies the types of information to be logged.
	//
	// This member is required.
	LogLevel LogLevel
}

Parameters used when defining a mitigation action that enable AWS IoT logging.

type ErrorInfo 

type ErrorInfo struct {

	// The error code.
	Code *string

	// The error message.
	Message *string
}

Error information.

type EventType 

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

Enum values for EventType

type ExplicitDeny 

type ExplicitDeny struct {

	// The policies that denied the authorization.
	Policies []*Policy
}

Information that explicitly denies authorization.

type ExponentialRolloutRate 

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).
	//
	// This member is required.
	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.
	//
	// This member is required.
	BaseRatePerMinute *int32

	// The exponential factor to increase the rate of rollout for a job.
	//
	// This member is required.
	IncrementFactor *float64
}

Allows you to create an exponential rate of rollout for a job.

type Field 

type Field struct {

	// The datatype of the field.
	Type FieldType

	// The name of the field.
	Name *string
}

Describes the name and data type at a field.

type FieldType 

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

Enum values for FieldType

type FileLocation 

type FileLocation struct {

	// The location of the updated firmware in S3.
	S3Location *S3Location

	// The stream that contains the OTA update.
	Stream *Stream
}

The location of the OTA update.

type FirehoseAction 

type FirehoseAction struct {

	// The IAM role that grants access to the Amazon Kinesis Firehose stream.
	//
	// This member is required.
	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.
	//
	// This member is required.
	DeliveryStreamName *string
}

Describes an action that writes data to an Amazon Kinesis Firehose stream.

type GroupNameAndArn 

type GroupNameAndArn struct {

	// The group ARN.
	GroupArn *string

	// The group name.
	GroupName *string
}

The name and ARN of a group.

type HttpAction 

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.
	//
	// This member is required.
	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
}

Send data to an HTTPS endpoint.

type HttpActionHeader 

type HttpActionHeader struct {

	// The HTTP header value. Substitution templates are supported.
	//
	// This member is required.
	Value *string

	// The HTTP header key.
	//
	// This member is required.
	Key *string
}

The HTTP action header.

type HttpAuthorization 

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
}

The authorization method used to send messages.

type HttpContext 

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
}

Specifies the HTTP context to use for the test authorizer request.

type HttpUrlDestinationConfiguration 

type HttpUrlDestinationConfiguration struct {

	// The URL AWS IoT uses to confirm ownership of or access to the topic rule
	// destination URL.
	//
	// This member is required.
	ConfirmationUrl *string
}

HTTP URL destination configuration used by the topic rule's HTTP action.

type HttpUrlDestinationProperties 

type HttpUrlDestinationProperties struct {

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

HTTP URL destination properties.

type HttpUrlDestinationSummary 

type HttpUrlDestinationSummary struct {

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

Information about an HTTP URL destination.

type ImplicitDeny 

type ImplicitDeny struct {

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

Information that implicitly denies authorization. When policy doesn't explicitly deny or allow an action on a resource it is considered an implicit deny.

type IndexNotReadyException 

type IndexNotReadyException struct {
	Message *string
}

The index is not ready.

func (*IndexNotReadyException) Error 

func (e *IndexNotReadyException) Error() string

func (*IndexNotReadyException) ErrorCode 

func (e *IndexNotReadyException) ErrorCode() string

func (*IndexNotReadyException) ErrorFault 

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

func (*IndexNotReadyException) ErrorMessage 

func (e *IndexNotReadyException) ErrorMessage() string

type IndexStatus 

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

Enum values for IndexStatus

type InternalException 

type InternalException struct {
	Message *string
}

An unexpected error has occurred.

func (*InternalException) Error 

func (e *InternalException) Error() string

func (*InternalException) ErrorCode 

func (e *InternalException) ErrorCode() string

func (*InternalException) ErrorFault 

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

func (*InternalException) ErrorMessage 

func (e *InternalException) ErrorMessage() string

type InternalFailureException 

type InternalFailureException struct {
	Message *string
}

An unexpected error has occurred.

func (*InternalFailureException) Error 

func (e *InternalFailureException) Error() string

func (*InternalFailureException) ErrorCode 

func (e *InternalFailureException) ErrorCode() string

func (*InternalFailureException) ErrorFault 

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

func (*InternalFailureException) ErrorMessage 

func (e *InternalFailureException) ErrorMessage() string

type InvalidAggregationException 

type InvalidAggregationException struct {
	Message *string
}

The aggregation is invalid.

func (*InvalidAggregationException) Error 

func (e *InvalidAggregationException) Error() string

func (*InvalidAggregationException) ErrorCode 

func (e *InvalidAggregationException) ErrorCode() string

func (*InvalidAggregationException) ErrorFault 

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

func (*InvalidAggregationException) ErrorMessage 

func (e *InvalidAggregationException) ErrorMessage() string

type InvalidQueryException 

type InvalidQueryException struct {
	Message *string
}

The query is invalid.

func (*InvalidQueryException) Error 

func (e *InvalidQueryException) Error() string

func (*InvalidQueryException) ErrorCode 

func (e *InvalidQueryException) ErrorCode() string

func (*InvalidQueryException) ErrorFault 

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

func (*InvalidQueryException) ErrorMessage 

func (e *InvalidQueryException) ErrorMessage() string

type InvalidRequestException 

type InvalidRequestException struct {
	Message *string
}

The request is not valid.

func (*InvalidRequestException) Error 

func (e *InvalidRequestException) Error() string

func (*InvalidRequestException) ErrorCode 

func (e *InvalidRequestException) ErrorCode() string

func (*InvalidRequestException) ErrorFault 

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

func (*InvalidRequestException) ErrorMessage 

func (e *InvalidRequestException) ErrorMessage() string

type InvalidResponseException 

type InvalidResponseException struct {
	Message *string
}

The response is invalid.

func (*InvalidResponseException) Error 

func (e *InvalidResponseException) Error() string

func (*InvalidResponseException) ErrorCode 

func (e *InvalidResponseException) ErrorCode() string

func (*InvalidResponseException) ErrorFault 

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

func (*InvalidResponseException) ErrorMessage 

func (e *InvalidResponseException) ErrorMessage() string

type InvalidStateTransitionException 

type InvalidStateTransitionException struct {
	Message *string
}

An attempt was made to change to an invalid state, for example by deleting a job or a job execution which is "IN_PROGRESS" without setting the force parameter.

func (*InvalidStateTransitionException) Error 

func (e *InvalidStateTransitionException) Error() string

func (*InvalidStateTransitionException) ErrorCode 

func (e *InvalidStateTransitionException) ErrorCode() string

func (*InvalidStateTransitionException) ErrorFault 

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

func (*InvalidStateTransitionException) ErrorMessage 

func (e *InvalidStateTransitionException) ErrorMessage() string

type IotAnalyticsAction 

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
}

Sends message data to an AWS IoT Analytics channel.

type IotEventsAction 

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").
	//
	// This member is required.
	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.
	//
	// This member is required.
	InputName *string
}

Sends an input to an AWS IoT Events detector.

type IotSiteWiseAction 

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.
	//
	// This member is required.
	RoleArn *string

	// A list of asset property value entries.
	//
	// This member is required.
	PutAssetPropertyValueEntries []*PutAssetPropertyValueEntry
}

Describes an action to send data from an MQTT message that triggered the rule to AWS IoT SiteWise asset properties.

type Job 

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
}

The Job object contains details about a job.

type JobExecution 

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
}

The job execution object represents the execution of a job on a particular device.

type JobExecutionFailureType 

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

Enum values for JobExecutionFailureType

type JobExecutionStatus 

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

Enum values for JobExecutionStatus

type JobExecutionStatusDetails 

type JobExecutionStatusDetails struct {

	// The job execution status.
	DetailsMap map[string]*string
}

Details of the job execution status.

type JobExecutionSummary 

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
}

The job execution summary.

type JobExecutionSummaryForJob 

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
}

Contains a summary of information about job executions for a specific job.

type JobExecutionSummaryForThing 

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
}

The job execution summary for a thing.

type JobExecutionsRolloutConfig 

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
}

Allows you to create a staged rollout of a job.

type JobProcessDetails 

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
}

The job process details.

type JobStatus 

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

Enum values for JobStatus

type JobSummary 

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
}

The job summary.

type KeyPair 

type KeyPair struct {

	// The private key.
	PrivateKey *string

	// The public key.
	PublicKey *string
}

Describes a key pair.

type KinesisAction 

type KinesisAction struct {

	// The name of the Amazon Kinesis stream.
	//
	// This member is required.
	StreamName *string

	// The ARN of the IAM role that grants access to the Amazon Kinesis stream.
	//
	// This member is required.
	RoleArn *string

	// The partition key.
	PartitionKey *string
}

Describes an action to write data to an Amazon Kinesis stream.

type LambdaAction 

type LambdaAction struct {

	// The ARN of the Lambda function.
	//
	// This member is required.
	FunctionArn *string
}

Describes an action to invoke a Lambda function.

type LimitExceededException 

type LimitExceededException struct {
	Message *string
}

A limit has been exceeded.

func (*LimitExceededException) Error 

func (e *LimitExceededException) Error() string

func (*LimitExceededException) ErrorCode 

func (e *LimitExceededException) ErrorCode() string

func (*LimitExceededException) ErrorFault 

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

func (*LimitExceededException) ErrorMessage 

func (e *LimitExceededException) ErrorMessage() string

type LogLevel 

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

Enum values for LogLevel

type LogTarget 

type LogTarget struct {

	// The target name.
	TargetName *string

	// The target type.
	//
	// This member is required.
	TargetType LogTargetType
}

A log target.

type LogTargetConfiguration 

type LogTargetConfiguration struct {

	// The logging level.
	LogLevel LogLevel

	// A log target
	LogTarget *LogTarget
}

The target configuration.

type LogTargetType 

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

Enum values for LogTargetType

type LoggingOptionsPayload 

type LoggingOptionsPayload struct {

	// The ARN of the IAM role that grants access.
	//
	// This member is required.
	RoleArn *string

	// The log level.
	LogLevel LogLevel
}

Describes the logging options payload.

type MalformedPolicyException 

type MalformedPolicyException struct {
	Message *string
}

The policy documentation is not valid.

func (*MalformedPolicyException) Error 

func (e *MalformedPolicyException) Error() string

func (*MalformedPolicyException) ErrorCode 

func (e *MalformedPolicyException) ErrorCode() string

func (*MalformedPolicyException) ErrorFault 

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

func (*MalformedPolicyException) ErrorMessage 

func (e *MalformedPolicyException) ErrorMessage() string

type MessageFormat 

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

Enum values for MessageFormat

type MetricDimension 

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.
	//
	// This member is required.
	DimensionName *string
}

The dimension of a metric.

type MetricToRetain 

type MetricToRetain struct {

	// What is measured by the behavior.
	//
	// This member is required.
	Metric *string

	// The dimension of a metric.
	MetricDimension *MetricDimension
}

The metric you want to retain. Dimensions are optional.

type MetricValue 

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
}

The value to be compared with the metric.

type MitigationAction 

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
}

Describes which changes should be applied as part of a mitigation action.

type MitigationActionIdentifier 

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
}

Information that identifies a mitigation action. This information is returned by ListMitigationActions.

type MitigationActionParams 

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
}

The set of parameters for this mitigation action. You can specify only one type of parameter (in other words, you can apply only one action for each defined mitigation action).

type MitigationActionType 

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

Enum values for MitigationActionType

type MqttContext 

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
}

Specifies the MQTT context to use for the test authorizer request

type NonCompliantResource 

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
}

Information about the resource that was noncompliant with the audit check.

type NotConfiguredException 

type NotConfiguredException struct {
	Message *string
}

The resource is not configured.

func (*NotConfiguredException) Error 

func (e *NotConfiguredException) Error() string

func (*NotConfiguredException) ErrorCode 

func (e *NotConfiguredException) ErrorCode() string

func (*NotConfiguredException) ErrorFault 

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

func (*NotConfiguredException) ErrorMessage 

func (e *NotConfiguredException) ErrorMessage() string

type OTAUpdateFile 

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
}

Describes a file to be associated with an OTA update.

type OTAUpdateInfo 

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
}

Information about an OTA update.

type OTAUpdateStatus 

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

Enum values for OTAUpdateStatus

type OTAUpdateSummary 

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
}

An OTA update summary.

type OutgoingCertificate 

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
}

A certificate that has been transferred but not yet accepted.

type PercentPair 

type PercentPair struct {

	// The percentile.
	Percent *float64

	// The value of the percentile.
	Value *float64
}

Describes the percentile and percentile value.

type Policy 

type Policy struct {

	// The policy name.
	PolicyName *string

	// The policy ARN.
	PolicyArn *string
}

Describes an AWS IoT policy.

type PolicyTemplateName 

type PolicyTemplateName string
const (
	PolicyTemplateNameBlank_policy PolicyTemplateName = "BLANK_POLICY"
)

Enum values for PolicyTemplateName

type PolicyVersion 

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
}

Describes a policy version.

type PolicyVersionIdentifier 

type PolicyVersionIdentifier struct {

	// The name of the policy.
	PolicyName *string

	// The ID of the version of the policy associated with the resource.
	PolicyVersionId *string
}

Information about the version of the policy associated with the resource.

type PresignedUrlConfig 

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
}

Configuration for pre-signed S3 URLs.

type Protocol 

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

Enum values for Protocol

type ProvisioningHook 

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.
	//
	// This member is required.
	TargetArn *string
}

Structure that contains payloadVersion and targetArn.

type ProvisioningTemplateSummary 

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
}

A summary of information about a fleet provisioning template.

type ProvisioningTemplateVersionSummary 

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
}

A summary of information about a fleet provision template version.

type PublishFindingToSnsParams 

type PublishFindingToSnsParams struct {

	// The ARN of the topic to which you want to publish the findings.
	//
	// This member is required.
	TopicArn *string
}

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.

type PutAssetPropertyValueEntry 

type PutAssetPropertyValueEntry struct {

	// A list of property values to insert that each contain timestamp, quality, and
	// value (TQV) information.
	//
	// This member is required.
	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
}

An asset property value entry containing the following information.

type PutItemInput 

type PutItemInput struct {

	// The table where the message data will be written.
	//
	// This member is required.
	TableName *string
}

The input for the DynamoActionVS action that specifies the DynamoDB table to which the message data will be written.

type RateIncreaseCriteria 

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
}

Allows you to define a criteria to initiate the increase in rate of rollout for a job.

type RegistrationCodeValidationException 

type RegistrationCodeValidationException struct {
	Message *string
}

The registration code is invalid.

func (*RegistrationCodeValidationException) Error 

func (e *RegistrationCodeValidationException) Error() string

func (*RegistrationCodeValidationException) ErrorCode 

func (e *RegistrationCodeValidationException) ErrorCode() string

func (*RegistrationCodeValidationException) ErrorFault 

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

func (*RegistrationCodeValidationException) ErrorMessage 

func (e *RegistrationCodeValidationException) ErrorMessage() string

type RegistrationConfig 

type RegistrationConfig struct {

	// The template body.
	TemplateBody *string

	// The ARN of the role.
	RoleArn *string
}

The registration configuration.

type RelatedResource 

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
}

Information about a related resource.

type ReplaceDefaultPolicyVersionParams 

type ReplaceDefaultPolicyVersionParams struct {

	// The name of the template to be applied. The only supported value is
	// BLANK_POLICY.
	//
	// This member is required.
	TemplateName PolicyTemplateName
}

Parameters to define a mitigation action that adds a blank policy to restrict permissions.

type ReportType 

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

Enum values for ReportType

type RepublishAction 

type RepublishAction struct {

	// The ARN of the IAM role that grants access.
	//
	// This member is required.
	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.
	//
	// This member is required.
	Topic *string
}

Describes an action to republish to another topic.

type ResourceAlreadyExistsException 

type ResourceAlreadyExistsException struct {
	Message *string

	ResourceId  *string
	ResourceArn *string
}

The resource already exists.

func (*ResourceAlreadyExistsException) Error 

func (e *ResourceAlreadyExistsException) Error() string

func (*ResourceAlreadyExistsException) ErrorCode 

func (e *ResourceAlreadyExistsException) ErrorCode() string

func (*ResourceAlreadyExistsException) ErrorFault 

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

func (*ResourceAlreadyExistsException) ErrorMessage 

func (e *ResourceAlreadyExistsException) ErrorMessage() string

type ResourceIdentifier 

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
}

Information that identifies the noncompliant resource.

type ResourceNotFoundException 

type ResourceNotFoundException struct {
	Message *string
}

The specified resource does not exist.

func (*ResourceNotFoundException) Error 

func (e *ResourceNotFoundException) Error() string

func (*ResourceNotFoundException) ErrorCode 

func (e *ResourceNotFoundException) ErrorCode() string

func (*ResourceNotFoundException) ErrorFault 

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

func (*ResourceNotFoundException) ErrorMessage 

func (e *ResourceNotFoundException) ErrorMessage() string

type ResourceRegistrationFailureException 

type ResourceRegistrationFailureException struct {
	Message *string
}

The resource registration failed.

func (*ResourceRegistrationFailureException) Error 

func (e *ResourceRegistrationFailureException) Error() string

func (*ResourceRegistrationFailureException) ErrorCode 

func (e *ResourceRegistrationFailureException) ErrorCode() string

func (*ResourceRegistrationFailureException) ErrorFault 

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

func (*ResourceRegistrationFailureException) ErrorMessage 

func (e *ResourceRegistrationFailureException) ErrorMessage() string

type ResourceType 

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

Enum values for ResourceType

type RoleAliasDescription 

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
}

Role alias description.

type S3Action 

type S3Action struct {

	// The object key.
	//
	// This member is required.
	Key *string

	// The ARN of the IAM role that grants access.
	//
	// This member is required.
	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.
	//
	// This member is required.
	BucketName *string
}

Describes an action to write data to an Amazon S3 bucket.

type S3Destination 

type S3Destination struct {

	// The S3 prefix.
	Prefix *string

	// The S3 bucket that contains the updated firmware.
	Bucket *string
}

Describes the location of updated firmware in S3.

type S3Location 

type S3Location struct {

	// The S3 bucket.
	Bucket *string

	// The S3 bucket version.
	Version *string

	// The S3 key.
	Key *string
}

The S3 location.

type SalesforceAction 

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.
	//
	// This member is required.
	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.
	//
	// This member is required.
	Url *string
}

Describes an action to write a message to a Salesforce IoT Cloud Input Stream.

type ScheduledAuditMetadata 

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
}

Information about the scheduled audit.

type SecurityProfileIdentifier 

type SecurityProfileIdentifier struct {

	// The ARN of the security profile.
	//
	// This member is required.
	Arn *string

	// The name you have given to the security profile.
	//
	// This member is required.
	Name *string
}

Identifying information for a Device Defender security profile.

type SecurityProfileTarget 

type SecurityProfileTarget struct {

	// The ARN of the security profile.
	//
	// This member is required.
	Arn *string
}

A target to which an alert is sent when a security profile behavior is violated.

type SecurityProfileTargetMapping 

type SecurityProfileTargetMapping struct {

	// Information about the target (thing group) associated with the security profile.
	Target *SecurityProfileTarget

	// Information that identifies the security profile.
	SecurityProfileIdentifier *SecurityProfileIdentifier
}

Information about a security profile and the target associated with it.

type ServerCertificateStatus 

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

Enum values for ServerCertificateStatus

type ServerCertificateSummary 

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
}

An object that contains information about a server certificate.

type ServiceType 

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

Enum values for ServiceType

type ServiceUnavailableException 

type ServiceUnavailableException struct {
	Message *string
}

The service is temporarily unavailable.

func (*ServiceUnavailableException) Error 

func (e *ServiceUnavailableException) Error() string

func (*ServiceUnavailableException) ErrorCode 

func (e *ServiceUnavailableException) ErrorCode() string

func (*ServiceUnavailableException) ErrorFault 

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

func (*ServiceUnavailableException) ErrorMessage 

func (e *ServiceUnavailableException) ErrorMessage() string

type SigV4Authorization 

type SigV4Authorization struct {

	// The service name to use while signing with Sig V4.
	//
	// This member is required.
	ServiceName *string

	// The signing region.
	//
	// This member is required.
	SigningRegion *string

	// The ARN of the signing role.
	//
	// This member is required.
	RoleArn *string
}

Use Sig V4 authorization.

type SigningProfileParameter 

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
}

Describes the code-signing profile.

type SnsAction 

type SnsAction struct {

	// The ARN of the IAM role that grants access.
	//
	// This member is required.
	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.
	//
	// This member is required.
	TargetArn *string
}

Describes an action to publish to an Amazon SNS topic.

type SqlParseException 

type SqlParseException struct {
	Message *string
}

The Rule-SQL expression can't be parsed correctly.

func (*SqlParseException) Error 

func (e *SqlParseException) Error() string

func (*SqlParseException) ErrorCode 

func (e *SqlParseException) ErrorCode() string

func (*SqlParseException) ErrorFault 

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

func (*SqlParseException) ErrorMessage 

func (e *SqlParseException) ErrorMessage() string

type SqsAction 

type SqsAction struct {

	// The ARN of the IAM role that grants access.
	//
	// This member is required.
	RoleArn *string

	// Specifies whether to use Base64 encoding.
	UseBase64 *bool

	// The URL of the Amazon SQS queue.
	//
	// This member is required.
	QueueUrl *string
}

Describes an action to publish data to an Amazon SQS queue.

type StartSigningJobParameter 

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
}

Information required to start a signing job.

type StatisticalThreshold 

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
}

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.

type Statistics 

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
}

A map of key-value pairs for all supported statistics. Currently, only count is supported.

type Status 

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

Enum values for Status

type StepFunctionsAction 

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").
	//
	// This member is required.
	RoleArn *string

	// The name of the Step Functions state machine whose execution will be started.
	//
	// This member is required.
	StateMachineName *string
}

Starts execution of a Step Functions state machine.

type Stream 

type Stream struct {

	// The ID of a file associated with a stream.
	FileId *int32

	// The stream ID.
	StreamId *string
}

Describes a group of files that can be streamed.

type StreamFile 

type StreamFile struct {

	// The file ID.
	FileId *int32

	// The location of the file in S3.
	S3Location *S3Location
}

Represents a file to stream.

type StreamInfo 

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
}

Information about a stream.

type StreamSummary 

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
}

A summary of a stream.

type Tag 

type Tag struct {

	// The tag's key.
	//
	// This member is required.
	Key *string

	// The tag's value.
	Value *string
}

A set of key/value pairs that are used to manage the resource.

type TargetSelection 

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

Enum values for TargetSelection

type TaskAlreadyExistsException 

type TaskAlreadyExistsException struct {
	Message *string
}

This exception occurs if you attempt to start a task with the same task-id as an existing task but with a different clientRequestToken.

func (*TaskAlreadyExistsException) Error 

func (e *TaskAlreadyExistsException) Error() string

func (*TaskAlreadyExistsException) ErrorCode 

func (e *TaskAlreadyExistsException) ErrorCode() string

func (*TaskAlreadyExistsException) ErrorFault 

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

func (*TaskAlreadyExistsException) ErrorMessage 

func (e *TaskAlreadyExistsException) ErrorMessage() string

type TaskStatistics 

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
}

Statistics for the checks performed during the audit.

type TaskStatisticsForAuditCheck 

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
}

Provides summary counts of how many tasks for findings are in a particular state. This information is included in the response from DescribeAuditMitigationActionsTask.

type ThingAttribute 

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
}

The properties of the thing, including thing name, thing type name, and a list of thing attributes.

type ThingConnectivity 

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
}

The connectivity status of the thing.

type ThingConnectivityIndexingMode 

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

Enum values for ThingConnectivityIndexingMode

type ThingDocument 

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
}

The thing search index document.

type ThingGroupDocument 

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
}

The thing group search index document.

type ThingGroupIndexingConfiguration 

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.
	//
	// This member is required.
	ThingGroupIndexingMode ThingGroupIndexingMode
}

Thing group indexing configuration.

type ThingGroupIndexingMode 

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

Enum values for ThingGroupIndexingMode

type ThingGroupMetadata 

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
}

Thing group metadata.

type ThingGroupProperties 

type ThingGroupProperties struct {

	// The thing group description.
	ThingGroupDescription *string

	// The thing group attributes in JSON format.
	AttributePayload *AttributePayload
}

Thing group properties.

type ThingIndexingConfiguration 

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.
	//
	// This member is required.
	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
}

The thing indexing configuration. For more information, see Managing Thing Indexing (https://docs.aws.amazon.com/iot/latest/developerguide/managing-index.html).

type ThingIndexingMode 

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

Enum values for ThingIndexingMode

type ThingTypeDefinition 

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
}

The definition of the thing type, including thing type name and description.

type ThingTypeMetadata 

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
}

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 time was deprecated.

type ThingTypeProperties 

type ThingTypeProperties struct {

	// The description of the thing type.
	ThingTypeDescription *string

	// A list of searchable thing attribute names.
	SearchableAttributes []*string
}

The ThingTypeProperties contains information about the thing type including: a thing type description, and a list of searchable thing attribute names.

type ThrottlingException 

type ThrottlingException struct {
	Message *string
}

The rate exceeds the limit.

func (*ThrottlingException) Error 

func (e *ThrottlingException) Error() string

func (*ThrottlingException) ErrorCode 

func (e *ThrottlingException) ErrorCode() string

func (*ThrottlingException) ErrorFault 

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

func (*ThrottlingException) ErrorMessage 

func (e *ThrottlingException) ErrorMessage() string

type TimeoutConfig 

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
}

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.

type TlsContext 

type TlsContext struct {

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

Specifies the TLS context to use for the test authorizer request.

type TopicRule 

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
}

Describes a rule.

type TopicRuleDestination 

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
}

A topic rule destination.

type TopicRuleDestinationConfiguration 

type TopicRuleDestinationConfiguration struct {

	// Configuration of the HTTP URL.
	HttpUrlConfiguration *HttpUrlDestinationConfiguration
}

Configuration of the topic rule destination.

type TopicRuleDestinationStatus 

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

Enum values for TopicRuleDestinationStatus

type TopicRuleDestinationSummary 

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
}

Information about the topic rule destination.

type TopicRuleListItem 

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
}

Describes a rule.

type TopicRulePayload 

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.
	//
	// This member is required.
	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.
	//
	// This member is required.
	Actions []*Action

	// The action to take when an error occurs.
	ErrorAction *Action

	// The description of the rule.
	Description *string
}

Describes a rule.

type TransferAlreadyCompletedException 

type TransferAlreadyCompletedException struct {
	Message *string
}

You can't revert the certificate transfer because the transfer is already complete.

func (*TransferAlreadyCompletedException) Error 

func (e *TransferAlreadyCompletedException) Error() string

func (*TransferAlreadyCompletedException) ErrorCode 

func (e *TransferAlreadyCompletedException) ErrorCode() string

func (*TransferAlreadyCompletedException) ErrorFault 

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

func (*TransferAlreadyCompletedException) ErrorMessage 

func (e *TransferAlreadyCompletedException) ErrorMessage() string

type TransferConflictException 

type TransferConflictException struct {
	Message *string
}

You can't transfer the certificate because authorization policies are still attached.

func (*TransferConflictException) Error 

func (e *TransferConflictException) Error() string

func (*TransferConflictException) ErrorCode 

func (e *TransferConflictException) ErrorCode() string

func (*TransferConflictException) ErrorFault 

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

func (*TransferConflictException) ErrorMessage 

func (e *TransferConflictException) ErrorMessage() string

type TransferData 

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
}

Data used to transfer a certificate to an AWS account.

type UnauthorizedException 

type UnauthorizedException struct {
	Message *string
}

You are not authorized to perform this operation.

func (*UnauthorizedException) Error 

func (e *UnauthorizedException) Error() string

func (*UnauthorizedException) ErrorCode 

func (e *UnauthorizedException) ErrorCode() string

func (*UnauthorizedException) ErrorFault 

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

func (*UnauthorizedException) ErrorMessage 

func (e *UnauthorizedException) ErrorMessage() string

type UpdateCACertificateParams 

type UpdateCACertificateParams struct {

	// The action that you want to apply to the CA cerrtificate. The only supported
	// value is DEACTIVATE.
	//
	// This member is required.
	Action CACertificateUpdateAction
}

Parameters to define a mitigation action that changes the state of the CA certificate to inactive.

type UpdateDeviceCertificateParams 

type UpdateDeviceCertificateParams struct {

	// The action that you want to apply to the device cerrtificate. The only supported
	// value is DEACTIVATE.
	//
	// This member is required.
	Action DeviceCertificateUpdateAction
}

Parameters to define a mitigation action that changes the state of the device certificate to inactive.

type ValidationError 

type ValidationError struct {

	// The description of an error found in the behaviors.
	ErrorMessage *string
}

Information about an error found in a behavior specification.

type VersionConflictException 

type VersionConflictException struct {
	Message *string
}

An exception thrown when the version of an entity specified with the expectedVersion parameter does not match the latest version in the system.

func (*VersionConflictException) Error 

func (e *VersionConflictException) Error() string

func (*VersionConflictException) ErrorCode 

func (e *VersionConflictException) ErrorCode() string

func (*VersionConflictException) ErrorFault 

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

func (*VersionConflictException) ErrorMessage 

func (e *VersionConflictException) ErrorMessage() string

type VersionsLimitExceededException 

type VersionsLimitExceededException struct {
	Message *string
}

The number of policy versions exceeds the limit.

func (*VersionsLimitExceededException) Error 

func (e *VersionsLimitExceededException) Error() string

func (*VersionsLimitExceededException) ErrorCode 

func (e *VersionsLimitExceededException) ErrorCode() string

func (*VersionsLimitExceededException) ErrorFault 

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

func (*VersionsLimitExceededException) ErrorMessage 

func (e *VersionsLimitExceededException) ErrorMessage() string

type ViolationEvent 

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
}

Information about a Device Defender security profile behavior violation.

type ViolationEventType 

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

Enum values for ViolationEventType

Source Files

View all Source files

Jump to

Keyboard shortcuts

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