Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Managed integrations for AWS IoT Device Management can respond with.

Structs

AbortConfigCriteria

Structure representing one abort config criteria.

CapabilityAction

Action for an Amazon Web Services capability, containing the action parameters for control.

CapabilityReport

Report of all capabilities supported by the device.

CapabilityReportCapability

The capability used in capability report.

CapabilityReportEndpoint

The endpoint used in the capability report.

CommandCapability

The command capabilities added for the managed thing

CommandEndpoint

The endpoint for a managed thing when sending a command.

ConfigurationError

Provides the default encryption configuration error update details.

ConfigurationStatus

Provides the status of the default encryption configuration for an Amazon Web Services account.

CredentialLockerSummary

Structure describing one Credential Locker.

DestinationSummary

Structure describing a destination for IoT managed integrations to deliver notifications for a device.

EventLogConfigurationSummary

List of event log configurations.

ExponentialRolloutRate

Structure representing exponential rate of rollout for an over-the-air (OTA) task.

ManagedThingSchemaListItem

Structure representing one schema item associated with a managed thing.

ManagedThingSummary

Structure representing one managed thing.

NotificationConfigurationSummary

Structure describing a notification configuration.

OtaTaskAbortConfig

Over-the-air (OTA) task abort config.

OtaTaskConfigurationSummary

Structure representing one over-the-air (OTA) task configuration.

OtaTaskExecutionRetryConfig

Over-the-air (OTA) task retry config.

OtaTaskExecutionRolloutConfig

Over-the-air (OTA) task rollout config.

OtaTaskExecutionSummaries

Structure representing one execution summary.

OtaTaskExecutionSummary

Structure representing one over-the-air (OTA) task execution summary.

OtaTaskSchedulingConfig

Over-the-air (OTA) task scheduling config.

OtaTaskSummary

Structure representing one over-the-air (OTA) task.

OtaTaskTimeoutConfig

Over-the-air (OTA) task timeout config.

ProvisioningProfileSummary

Structure describing a provisioning profile.

PushConfig

Structure representing a push config.

RetryConfigCriteria

Structure representing one retry config criteria.

RolloutRateIncreaseCriteria

Structure representing rollout config criteria.

RuntimeLogConfigurations

The different configurations for runtime logs.

ScheduleMaintenanceWindow

Structure representing scheduling maintenance window.

SchemaVersionListItem

List item describing a schema version.

StateCapability

State capabilities added for the managed thing.

StateEndpoint

Describe the endpoint with an Id, a name, and the relevant capabilities for reporting state

TaskProcessingDetails

Details about the over-the-air (OTA) task process.

Enums

AbortCriteriaAction

When writing a match expression against AbortCriteriaAction, 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.

AbortCriteriaFailureType

When writing a match expression against AbortCriteriaFailureType, 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.

AuthMaterialType

When writing a match expression against AuthMaterialType, 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.

ConfigurationState

When writing a match expression against ConfigurationState, 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.

DeliveryDestinationType

When writing a match expression against DeliveryDestinationType, 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.

DeviceDiscoveryStatus

When writing a match expression against DeviceDiscoveryStatus, 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.

DiscoveryAuthMaterialType

When writing a match expression against DiscoveryAuthMaterialType, 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.

DiscoveryType

When writing a match expression against DiscoveryType, 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.

EncryptionType

When writing a match expression against EncryptionType, 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.

HubNetworkMode

When writing a match expression against HubNetworkMode, 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.

OtaMechanism

When writing a match expression against OtaMechanism, 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.

OtaProtocol

When writing a match expression against OtaProtocol, 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.

OtaStatus

When writing a match expression against OtaStatus, 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.

OtaTaskExecutionStatus

When writing a match expression against OtaTaskExecutionStatus, 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.

OtaType

When writing a match expression against OtaType, 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.

ProvisioningStatus

When writing a match expression against ProvisioningStatus, 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.

ProvisioningType

When writing a match expression against ProvisioningType, 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.

RetryCriteriaFailureType

When writing a match expression against RetryCriteriaFailureType, 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.

Role

When writing a match expression against Role, 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.

SchedulingConfigEndBehavior

When writing a match expression against SchedulingConfigEndBehavior, 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.

SchemaVersionFormat

When writing a match expression against SchemaVersionFormat, 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.

SchemaVersionType

When writing a match expression against SchemaVersionType, 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.

SchemaVersionVisibility

When writing a match expression against SchemaVersionVisibility, 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.