Module types

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.

Behavior

A Device Defender security profile behavior.

BehaviorCriteria

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

BehaviorModelTrainingSummary

The summary of an ML Detect behavior model.

BillingGroupMetadata

Additional information about the billing group.

BillingGroupProperties

The properties of a billing group.

Bucket

A count of documents that meets a specific aggregation criteria.

BucketsAggregationType

The type of bucketed aggregation performed.

CaCertificate

A CA certificate.

CaCertificateDescription

Describes a CA certificate.

Certificate

Information about a certificate.

CertificateDescription

Describes a certificate.

CertificateProviderSummary

The certificate provider summary.

CertificateValidity

When the certificate is valid.

ClientCertificateConfig

An object that speciﬁes the client certificate conﬁguration for a domain.

CloudwatchAlarmAction

Describes an action that updates a CloudWatch alarm.

CloudwatchLogsAction

Describes an action that sends data to CloudWatch Logs.

CloudwatchMetricAction

Describes an action that captures a CloudWatch metric.

CodeSigning

Describes the method to use when code signing a file.

CodeSigningCertificateChain

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

CodeSigningSignature

Describes the signature for a file.

CommandExecutionResult

The result value of the command execution. The device can use the result field to share additional details about the execution such as a return value of a remote function call.

This field is not applicable if you use the AWS-IoT-FleetWise namespace.

CommandExecutionSummary

Summary information about a particular command execution.

CommandParameter

A map of key-value pairs that describe the command.

CommandParameterValue

The range of possible values that's used to describe a specific command parameter.

The commandParameterValue can only have one of the below fields listed.

CommandPayload

The command payload object that contains the instructions for the device to process.

CommandSummary

Summary information about a particular command resource.

Configuration

Configuration.

CustomCodeSigning

Describes a custom method used to code sign a file.

Denied

Contains information that denied the authorization.

Destination

Describes the location of the updated firmware.

DetectMitigationActionExecution

Describes which mitigation actions should be executed.

DetectMitigationActionsTaskStatistics

The statistics of a mitigation action task.

DetectMitigationActionsTaskSummary

The summary of the mitigation action tasks.

DetectMitigationActionsTaskTarget

The target of a mitigation action task.

DocumentParameter

A map of key-value pairs containing the patterns that need to be replaced in a managed template job document schema. You can use the description of each key as a guidance to specify the inputs during runtime when creating a job.

documentParameters can only be used when creating jobs from Amazon Web Services managed templates. This parameter can't be used with custom job templates or to create jobs from them.

DomainConfigurationSummary

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 Amazon Web Services-managed domain (for example, dbc123defghijk.iot.us-west-2.amazonaws.com), a customer managed domain, or a default endpoint.

Data
Jobs
CredentialProvider

DynamoDBv2Action

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.

DynamoDbAction

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

EffectivePolicy

The policy that has the effect on the authorization results.

ElasticsearchAction

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

The Elasticsearch action can only be used by existing rule actions. To create a new rule action or to update an existing rule action, use the OpenSearch rule action instead. For more information, see OpenSearchAction.

EnableIoTLoggingParams

Parameters used when defining a mitigation action that enable Amazon Web Services IoT Core logging.

ErrorInfo

Error information.

ExplicitDeny

Information that explicitly denies authorization.

ExponentialRolloutRate

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

Field

Describes the name and data type at a field.

FileLocation

The location of the OTA update.

FirehoseAction

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

FleetMetricNameAndArn

The name and ARN of a fleet metric.

GeoLocationTarget

A geolocation target that you select to index. Each geolocation target contains a name and order key-value pair that specifies the geolocation target fields.

GroupNameAndArn

The name and ARN of a group.

HttpAction

Send data to an HTTPS endpoint.

HttpActionHeader

The HTTP action header.

HttpAuthorization

The authorization method used to send messages.

HttpContext

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

HttpUrlDestinationConfiguration

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

HttpUrlDestinationProperties

HTTP URL destination properties.

HttpUrlDestinationSummary

Information about an HTTP URL destination.

ImplicitDeny

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

IndexingFilter

Provides additional selections for named shadows and geolocation data.

To add named shadows to your fleet indexing configuration, set namedShadowIndexingMode to be ON and specify your shadow names in namedShadowNames filter.

To add geolocation data to your fleet indexing configuration:

If you store geolocation data in a class/unnamed shadow, set thingIndexingMode to be REGISTRY_AND_SHADOW and specify your geolocation data in geoLocations filter.
If you store geolocation data in a named shadow, set namedShadowIndexingMode to be ON, add the shadow name in namedShadowNames filter, and specify your geolocation data in geoLocations filter. For more information, see Managing fleet indexing.

IotAnalyticsAction

Sends message data to an IoT Analytics channel.

IotEventsAction

Sends an input to an IoT Events detector.

IotSiteWiseAction

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

IssuerCertificateIdentifier

The certificate issuer indentifier.

Job

The Job object contains details about a job.

JobExecution

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

JobExecutionStatusDetails

Details of the job execution status.

JobExecutionSummary

The job execution summary.

JobExecutionSummaryForJob

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

JobExecutionSummaryForThing

The job execution summary for a thing.

JobExecutionsRetryConfig

The configuration that determines how many retries are allowed for each failure type for a job.

JobExecutionsRolloutConfig

Allows you to create a staged rollout of a job.

JobProcessDetails

The job process details.

JobSummary

The job summary.

JobTemplateSummary

An object that contains information about the job template.

KafkaAction

Send messages to an Amazon Managed Streaming for Apache Kafka (Amazon MSK) or self-managed Apache Kafka cluster.

KafkaActionHeader

Specifies a Kafka header using key-value pairs when you create a Rule’s Kafka Action. You can use these headers to route data from IoT clients to downstream Kafka clusters without modifying your message payload.

For more information about Rule's Kafka action, see Apache Kafka.

KeyPair

Describes a key pair.

KinesisAction

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

LambdaAction

Describes an action to invoke a Lambda function.

LocationAction

The Amazon Location rule action sends device location updates from an MQTT message to an Amazon Location tracker resource.

LocationTimestamp

Describes how to interpret an application-defined timestamp value from an MQTT message payload and the precision of that value.

LogTarget

A log target.

LogTargetConfiguration

The target configuration.

LoggingOptionsPayload

Describes the logging options payload.

MachineLearningDetectionConfig

The configuration of an ML Detect Security Profile.

MaintenanceWindow

An optional configuration within the SchedulingConfig to setup a recurring maintenance window with a predetermined start time and duration for the rollout of a job document to all devices in a target group for a job.

ManagedJobTemplateSummary

An object that contains information about the managed template.

MetricDatum

A metric.

MetricDimension

The dimension of a metric.

MetricToRetain

The metric you want to retain. Dimensions are optional.

MetricValue

The value to be compared with the metric.

MetricsExportConfig

Set configurations for metrics export.

MitigationAction

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

MitigationActionIdentifier

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

MitigationActionParams

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

Mqtt5Configuration

The configuration to add user-defined properties to enrich MQTT 5 messages.

MqttContext

Specifies the MQTT context to use for the test authorizer request

MqttHeaders

Specifies MQTT Version 5.0 headers information. For more information, see MQTT from Amazon Web Services IoT Core Developer Guide.

NonCompliantResource

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

OpenSearchAction

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

OtaUpdateFile

Describes a file to be associated with an OTA update.

OtaUpdateInfo

Information about an OTA update.

OtaUpdateSummary

An OTA update summary.

OutgoingCertificate

A certificate that has been transferred but not yet accepted.

PackageSummary

A summary of information about a software package.

PackageVersionArtifact

A specific package version artifact associated with a software package version.

PackageVersionSummary

A summary of information about a package version.

PercentPair

Describes the percentile and percentile value.

Policy

Describes an IoT policy.

PolicyVersion

Describes a policy version.

PolicyVersionIdentifier

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

PresignedUrlConfig

Configuration for pre-signed S3 URLs.

PrincipalThingObject

An object that represents the thing and the type of relation it has with the principal.

PropagatingAttribute

An object that represents the connection attribute, thing attribute, and the user property key.

ProvisioningHook

Structure that contains payloadVersion and targetArn.

ProvisioningTemplateSummary

A summary of information about a provisioning template.

ProvisioningTemplateVersionSummary

A summary of information about a fleet provision template version.

PublishFindingToSnsParams

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.

PutAssetPropertyValueEntry

An asset property value entry containing the following information.

PutItemInput

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

RateIncreaseCriteria

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

RegistrationConfig

The registration configuration.

RelatedResource

Information about a related resource.

ReplaceDefaultPolicyVersionParams

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

RepublishAction

Describes an action to republish to another topic.

ResourceIdentifier

Information that identifies the noncompliant resource.

RetryCriteria

The criteria that determines how many retries are allowed for each failure type for a job.

RoleAliasDescription

Role alias description.

S3Action

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

S3Destination

Describes the location of updated firmware in S3.

S3Location

The S3 location.

SalesforceAction

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

Sbom

A specific software bill of matrerials associated with a software package version.

SbomValidationResultSummary

A summary of the validation results for a specific software bill of materials (SBOM) attached to a software package version.

ScheduledAuditMetadata

Information about the scheduled audit.

ScheduledJobRollout

Displays the next seven maintenance window occurrences and their start times.

SchedulingConfig

Specifies the date and time that a job will begin the rollout of the job document to all devices in the target group. Additionally, you can specify the end behavior for each job execution when it reaches the scheduled end time.

SecurityProfileIdentifier

Identifying information for a Device Defender security profile.

SecurityProfileTarget

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

SecurityProfileTargetMapping

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

ServerCertificateConfig

The server certificate configuration.

ServerCertificateSummary

An object that contains information about a server certificate.

SigV4Authorization

For more information, see Signature Version 4 signing process.

SigningProfileParameter

Describes the code-signing profile.

SnsAction

Describes an action to publish to an Amazon SNS topic.

SqsAction

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

StartSigningJobParameter

Information required to start a signing job.

StatisticalThreshold

A statistical ranking (percentile) that indicates a threshold value by which a behavior is determined to be in compliance or in violation of the behavior.

Statistics

A map of key-value pairs for all supported statistics. For issues with missing or unexpected values for this API, consult Fleet indexing troubleshooting guide.

StatusReason

Provide additional context about the status of a command execution using a reason code and description.

StepFunctionsAction

Starts execution of a Step Functions state machine.

Stream

Describes a group of files that can be streamed.

StreamFile

Represents a file to stream.

StreamInfo

Information about a stream.

StreamSummary

A summary of a stream.

Tag

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

TaskStatistics

Statistics for the checks performed during the audit.

TaskStatisticsForAuditCheck

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

TermsAggregation

Performs an aggregation that will return a list of buckets. The list of buckets is a ranked list of the number of occurrences of an aggregation field value.

ThingAttribute

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

ThingConnectivity

The connectivity status of the thing.

ThingDocument

The thing search index document.

ThingGroupDocument

The thing group search index document.

ThingGroupIndexingConfiguration

Thing group indexing configuration.

ThingGroupMetadata

Thing group metadata.

ThingGroupProperties

Thing group properties.

ThingIndexingConfiguration

The thing indexing configuration. For more information, see Managing Thing Indexing.

ThingPrincipalObject

An object that represents the principal and the type of relation it has with the thing.

ThingTypeDefinition

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

ThingTypeMetadata

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.

ThingTypeProperties

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

TimeFilter

A filter that can be used to list command executions for a device that started or completed before or after a particular date and time.

TimeoutConfig

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.

TimestreamAction

The Timestream rule action writes attributes (measures) from an MQTT message into an Amazon Timestream table. For more information, see the Timestream topic rule action documentation.

TimestreamDimension

Metadata attributes of the time series that are written in each measure record.

TimestreamTimestamp

Describes how to interpret an application-defined timestamp value from an MQTT message payload and the precision of that value.

TlsConfig

An object that specifies the TLS configuration for a domain.

TlsContext

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

TopicRule

Describes a rule.

TopicRuleDestination

A topic rule destination.

TopicRuleDestinationConfiguration

Configuration of the topic rule destination.

TopicRuleDestinationSummary

Information about the topic rule destination.

TopicRuleListItem

Describes a rule.

TopicRulePayload

Describes a rule.

TransferData

Data used to transfer a certificate to an Amazon Web Services account.

UpdateCaCertificateParams

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

UpdateDeviceCertificateParams

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

UserProperty

A key-value pair that you define in the header. Both the key and the value are either literal strings or valid substitution templates.

ValidationError

Information about an error found in a behavior specification.

VersionUpdateByJobsConfig

Configuration to manage IoT Job's package version reporting. If configured, Jobs updates the thing's reserved named shadow with the package version information up on successful job completion.

Note: For each job, the destinationPackageVersions attribute has to be set with the correct data for Jobs to report to the thing shadow.

ViolationEvent

Information about a Device Defender security profile behavior violation.

ViolationEventAdditionalInfo

The details of a violation event.

ViolationEventOccurrenceRange

Specifies the time period of which violation events occurred between.

VpcDestinationConfiguration

The configuration information for a virtual private cloud (VPC) destination.

VpcDestinationProperties

The properties of a virtual private cloud (VPC) destination.

VpcDestinationSummary

The summary of a virtual private cloud (VPC) destination.

Enums§

AbortAction: When writing a match expression against AbortAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ActionType: When writing a match expression against ActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AggregationTypeName: When writing a match expression against AggregationTypeName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AlertTargetType: When writing a match expression against AlertTargetType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ApplicationProtocol: When writing a match expression against ApplicationProtocol, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AssetPropertyVariant: Contains an asset property value (of a single type).
AuditCheckRunStatus: When writing a match expression against AuditCheckRunStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuditFindingSeverity: When writing a match expression against AuditFindingSeverity, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuditFrequency: When writing a match expression against AuditFrequency, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuditMitigationActionsExecutionStatus: When writing a match expression against AuditMitigationActionsExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuditMitigationActionsTaskStatus: When writing a match expression against AuditMitigationActionsTaskStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuditNotificationType: When writing a match expression against AuditNotificationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuditTaskStatus: When writing a match expression against AuditTaskStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuditTaskType: When writing a match expression against AuditTaskType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuthDecision: When writing a match expression against AuthDecision, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuthenticationType: When writing a match expression against AuthenticationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuthorizerStatus: When writing a match expression against AuthorizerStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AutoRegistrationStatus: When writing a match expression against AutoRegistrationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AwsJobAbortCriteriaAbortAction: When writing a match expression against AwsJobAbortCriteriaAbortAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AwsJobAbortCriteriaFailureType: When writing a match expression against AwsJobAbortCriteriaFailureType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
BehaviorCriteriaType: When writing a match expression against BehaviorCriteriaType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CaCertificateStatus: When writing a match expression against CaCertificateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CaCertificateUpdateAction: When writing a match expression against CaCertificateUpdateAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CannedAccessControlList: When writing a match expression against CannedAccessControlList, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CertificateMode: When writing a match expression against CertificateMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CertificateProviderOperation: When writing a match expression against CertificateProviderOperation, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CertificateStatus: When writing a match expression against CertificateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CommandExecutionStatus: When writing a match expression against CommandExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CommandNamespace: When writing a match expression against CommandNamespace, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ComparisonOperator: When writing a match expression against ComparisonOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ConfidenceLevel: When writing a match expression against ConfidenceLevel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ConfigName: When writing a match expression against ConfigName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CustomMetricType: When writing a match expression against CustomMetricType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DayOfWeek: When writing a match expression against DayOfWeek, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DetectMitigationActionExecutionStatus: When writing a match expression against DetectMitigationActionExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DetectMitigationActionsTaskStatus: When writing a match expression against DetectMitigationActionsTaskStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DeviceCertificateUpdateAction: When writing a match expression against DeviceCertificateUpdateAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DeviceDefenderIndexingMode: When writing a match expression against DeviceDefenderIndexingMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DimensionType: When writing a match expression against DimensionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DimensionValueOperator: When writing a match expression against DimensionValueOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DisconnectReasonValue: When writing a match expression against DisconnectReasonValue, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DomainConfigurationStatus: When writing a match expression against DomainConfigurationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DomainType: When writing a match expression against DomainType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DynamicGroupStatus: When writing a match expression against DynamicGroupStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DynamoKeyType: When writing a match expression against DynamoKeyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
EventType: When writing a match expression against EventType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FieldType: When writing a match expression against FieldType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FleetMetricUnit: When writing a match expression against FleetMetricUnit, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
IndexStatus: When writing a match expression against IndexStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
JobEndBehavior: When writing a match expression against JobEndBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
JobExecutionFailureType: When writing a match expression against JobExecutionFailureType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
JobExecutionStatus: When writing a match expression against JobExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
JobStatus: When writing a match expression against JobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LogLevel: When writing a match expression against LogLevel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LogTargetType: When writing a match expression against LogTargetType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
MessageFormat: When writing a match expression against MessageFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
MitigationActionType: When writing a match expression against MitigationActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ModelStatus: When writing a match expression against ModelStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
NamedShadowIndexingMode: When writing a match expression against NamedShadowIndexingMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
OtaUpdateStatus: When writing a match expression against OtaUpdateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
PackageVersionAction: When writing a match expression against PackageVersionAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
PackageVersionStatus: When writing a match expression against PackageVersionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
PolicyTemplateName: When writing a match expression against PolicyTemplateName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
Protocol: When writing a match expression against Protocol, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ReportType: When writing a match expression against ReportType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ResourceType: When writing a match expression against ResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
RetryableFailureType: When writing a match expression against RetryableFailureType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SbomValidationErrorCode: When writing a match expression against SbomValidationErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SbomValidationResult: When writing a match expression against SbomValidationResult, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SbomValidationStatus: When writing a match expression against SbomValidationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ServerCertificateStatus: When writing a match expression against ServerCertificateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ServiceType: When writing a match expression against ServiceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SortOrder: When writing a match expression against SortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
Status: When writing a match expression against Status, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
TargetFieldOrder: When writing a match expression against TargetFieldOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
TargetSelection: When writing a match expression against TargetSelection, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
TemplateType: When writing a match expression against TemplateType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ThingConnectivityIndexingMode: When writing a match expression against ThingConnectivityIndexingMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ThingGroupIndexingMode: When writing a match expression against ThingGroupIndexingMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ThingIndexingMode: When writing a match expression against ThingIndexingMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ThingPrincipalType: When writing a match expression against ThingPrincipalType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
TopicRuleDestinationStatus: When writing a match expression against TopicRuleDestinationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
VerificationState: When writing a match expression against VerificationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ViolationEventType: When writing a match expression against ViolationEventType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Module typesCopy item path

Modules§

Structs§

Enums§

Module types