Expand description
Data structures used by operation inputs/outputs.
Modules§
- Builders
- Error types that AWS IoT can respond with.
Structs§
The criteria that determine when and how a job abort takes place.
The criteria that determine when and how a job abort takes place.
Describes the actions associated with a rule.
Information about an active Device Defender security profile behavior violation.
Parameters used when defining a mitigation action that move a set of things to a thing group.
The type of aggregation queries.
A structure containing the alert target ARN and the role ARN.
Contains information that allowed the authorization.
An asset property timestamp entry containing the following information.
An asset property value entry containing the following information.
The attribute payload.
Which audit checks are enabled and disabled for this account.
Information about the audit check.
The findings (results) of the audit.
Returned by ListAuditMitigationActionsTask, this object contains information that describes a mitigation action that has been started.
Information about an audit mitigation actions task that is returned by
ListAuditMitigationActionsTasks.Used in MitigationActionParams, this information identifies the target findings to which the mitigation actions are applied. Only one entry appears.
Information about the targets to which audit notifications are sent.
Filters out specific findings of a Device Defender audit.
The audits that were performed.
A collection of authorization information.
The authorizer result.
An object that specifies the authorization service for a domain.
The authorizer description.
The authorizer summary.
The criteria that determine when and how a job abort takes place.
The criteria that determine when and how a job abort takes place.
Configuration for the rollout of OTA updates.
The rate of increase for a job rollout. This parameter allows you to define an exponential rate increase for a job rollout.
Configuration information for pre-signed URLs. Valid when
protocolscontains HTTP.The criteria to initiate the increase in rate of rollout for a job.
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 toTIMED_OUT.A Device Defender security profile behavior.
The criteria by which the behavior is determined to be normal.
The summary of an ML Detect behavior model.
Additional information about the billing group.
The properties of a billing group.
A count of documents that meets a specific aggregation criteria.
The type of bucketed aggregation performed.
A CA certificate.
Describes a CA certificate.
Information about a certificate.
Describes a certificate.
The certificate provider summary.
When the certificate is valid.
An object that specifies the client certificate configuration for a domain.
Describes an action that updates a CloudWatch alarm.
Describes an action that sends data to CloudWatch Logs.
Describes an action that captures a CloudWatch metric.
Describes the method to use when code signing a file.
Describes the certificate chain being used when code signing a file.
Describes the signature for a file.
Configuration.
Describes a custom method used to code sign a file.
Contains information that denied the authorization.
Describes the location of the updated firmware.
Describes which mitigation actions should be executed.
The statistics of a mitigation action task.
The summary of the mitigation action tasks.
The target of a mitigation action task.
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.
documentParameterscan 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.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
-
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.
Describes an action to write to a DynamoDB table.
The
tableName,hashKeyField, andrangeKeyFieldvalues must match the values used when you created the table.The
hashKeyValueandrangeKeyvaluefields 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()}"The policy that has the effect on the authorization results.
Describes an action that writes data to an Amazon OpenSearch Service domain.
The
Elasticsearchaction can only be used by existing rule actions. To create a new rule action or to update an existing rule action, use theOpenSearchrule action instead. For more information, see OpenSearchAction.Parameters used when defining a mitigation action that enable Amazon Web Services IoT Core logging.
Error information.
Information that explicitly denies authorization.
Allows you to create an exponential rate of rollout for a job.
Describes the name and data type at a field.
The location of the OTA update.
Describes an action that writes data to an Amazon Kinesis Firehose stream.
The name and ARN of a fleet metric.
A geolocation target that you select to index. Each geolocation target contains a
nameandorderkey-value pair that specifies the geolocation target fields.The name and ARN of a group.
Send data to an HTTPS endpoint.
The HTTP action header.
The authorization method used to send messages.
Specifies the HTTP context to use for the test authorizer request.
HTTP URL destination configuration used by the topic rule's HTTP action.
HTTP URL destination properties.
Information about an HTTP URL destination.
Information that implicitly denies authorization. When policy doesn't explicitly deny or allow an action on a resource it is considered an implicit deny.
Provides additional selections for named shadows and geolocation data.
To add named shadows to your fleet indexing configuration, set
namedShadowIndexingModeto be ON and specify your shadow names innamedShadowNamesfilter.To add geolocation data to your fleet indexing configuration:
-
If you store geolocation data in a class/unnamed shadow, set
thingIndexingModeto beREGISTRY_AND_SHADOWand specify your geolocation data ingeoLocationsfilter. -
If you store geolocation data in a named shadow, set
namedShadowIndexingModeto beON, add the shadow name innamedShadowNamesfilter, and specify your geolocation data ingeoLocationsfilter. For more information, see Managing fleet indexing.
-
Sends message data to an IoT Analytics channel.
Sends an input to an IoT Events detector.
Describes an action to send data from an MQTT message that triggered the rule to IoT SiteWise asset properties.
The certificate issuer indentifier.
The
Jobobject contains details about a job.The job execution object represents the execution of a job on a particular device.
Details of the job execution status.
The job execution summary.
Contains a summary of information about job executions for a specific job.
The job execution summary for a thing.
The configuration that determines how many retries are allowed for each failure type for a job.
Allows you to create a staged rollout of a job.
The job process details.
The job summary.
An object that contains information about the job template.
Send messages to an Amazon Managed Streaming for Apache Kafka (Amazon MSK) or self-managed Apache Kafka cluster.
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.
Describes a key pair.
Describes an action to write data to an Amazon Kinesis stream.
Describes an action to invoke a Lambda function.
The Amazon Location rule action sends device location updates from an MQTT message to an Amazon Location tracker resource.
Describes how to interpret an application-defined timestamp value from an MQTT message payload and the precision of that value.
A log target.
The target configuration.
Describes the logging options payload.
The configuration of an ML Detect Security Profile.
An optional configuration within the
SchedulingConfigto 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.An object that contains information about the managed template.
A metric.
The dimension of a metric.
The metric you want to retain. Dimensions are optional.
The value to be compared with the
metric.Set configurations for metrics export.
Describes which changes should be applied as part of a mitigation action.
Information that identifies a mitigation action. This information is returned by ListMitigationActions.
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).
Specifies the MQTT context to use for the test authorizer request
Specifies MQTT Version 5.0 headers information. For more information, see MQTT from Amazon Web Services IoT Core Developer Guide.
Information about the resource that was noncompliant with the audit check.
Describes an action that writes data to an Amazon OpenSearch Service domain.
Describes a file to be associated with an OTA update.
Information about an OTA update.
An OTA update summary.
A certificate that has been transferred but not yet accepted.
A summary of information about a software package.
A specific package version artifact associated with a software package version.
A summary of information about a package version.
Describes the percentile and percentile value.
Describes an IoT policy.
Describes a policy version.
Information about the version of the policy associated with the resource.
Configuration for pre-signed S3 URLs.
Structure that contains
payloadVersionandtargetArn.A summary of information about a provisioning template.
A summary of information about a fleet provision template version.
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.
An asset property value entry containing the following information.
The input for the DynamoActionVS action that specifies the DynamoDB table to which the message data will be written.
Allows you to define a criteria to initiate the increase in rate of rollout for a job.
The registration configuration.
Information about a related resource.
Parameters to define a mitigation action that adds a blank policy to restrict permissions.
Describes an action to republish to another topic.
Information that identifies the noncompliant resource.
The criteria that determines how many retries are allowed for each failure type for a job.
Role alias description.
Describes an action to write data to an Amazon S3 bucket.
Describes the location of updated firmware in S3.
The S3 location.
Describes an action to write a message to a Salesforce IoT Cloud Input Stream.
A specific software bill of matrerials associated with a software package version.
A summary of the validation results for a specific software bill of materials (SBOM) attached to a software package version.
Information about the scheduled audit.
Displays the next seven maintenance window occurrences and their start times.
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.
Identifying information for a Device Defender security profile.
A target to which an alert is sent when a security profile behavior is violated.
Information about a security profile and the target associated with it.
The server certificate configuration.
An object that contains information about a server certificate.
For more information, see Signature Version 4 signing process.
Describes the code-signing profile.
Describes an action to publish to an Amazon SNS topic.
Describes an action to publish data to an Amazon SQS queue.
Information required to start a signing job.
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.
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.
Starts execution of a Step Functions state machine.
Describes a group of files that can be streamed.
Represents a file to stream.
Information about a stream.
A summary of a stream.
A set of key/value pairs that are used to manage the resource.
Statistics for the checks performed during the audit.
Provides summary counts of how many tasks for findings are in a particular state. This information is included in the response from DescribeAuditMitigationActionsTask.
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.
The properties of the thing, including thing name, thing type name, and a list of thing attributes.
The connectivity status of the thing.
The thing search index document.
The thing group search index document.
Thing group indexing configuration.
Thing group metadata.
Thing group properties.
The thing indexing configuration. For more information, see Managing Thing Indexing.
The definition of the thing type, including thing type name and description.
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.
The ThingTypeProperties contains information about the thing type including: a thing type description, and a list of searchable thing attribute names.
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 toTIMED_OUT.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.
Metadata attributes of the time series that are written in each measure record.
Describes how to interpret an application-defined timestamp value from an MQTT message payload and the precision of that value.
An object that specifies the TLS configuration for a domain.
Specifies the TLS context to use for the test authorizer request.
Describes a rule.
A topic rule destination.
Configuration of the topic rule destination.
Information about the topic rule destination.
Describes a rule.
Describes a rule.
Data used to transfer a certificate to an Amazon Web Services account.
Parameters to define a mitigation action that changes the state of the CA certificate to inactive.
Parameters to define a mitigation action that changes the state of the device certificate to inactive.
A key-value pair that you define in the header. Both the key and the value are either literal strings or valid substitution templates.
Information about an error found in a behavior specification.
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.
Information about a Device Defender security profile behavior violation.
The details of a violation event.
Specifies the time period of which violation events occurred between.
The configuration information for a virtual private cloud (VPC) destination.
The properties of a virtual private cloud (VPC) destination.
The summary of a virtual private cloud (VPC) destination.
Enums§
- 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. - 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. - 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. - 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. - 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. Contains an asset property value (of a single type).
- 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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. - 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.