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.

AccountAssociationItem

Structure containing information about an account association, including its identifier, state, and related metadata.

AuthConfig

The authentication configuration details for a connector destination, including OAuth settings and other authentication parameters.

AuthConfigUpdate

The updated authentication configuration details for a connector destination.

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.

CapabilitySchemaItem

Structure representing a capability schema item that defines the functionality and features supported by a managed thing.

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.

ConnectorDestinationSummary

Structure containing summary information about a connector destination, which defines how a cloud-to-cloud connector connects to a customer's AWS account.

ConnectorItem

Structure describing a connector.

CredentialLockerSummary

Structure describing one Credential Locker.

DestinationSummary

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

Device

Describe the device using the relevant metadata and supported clusters for device discovery.

DeviceDiscoverySummary

Structure containing summary information about a device discovery job, including its identifier, type, and status.

DiscoveredDeviceSummary

Structure containing summary information about a device discovered during a device discovery job.

EndpointConfig

The configuration details for an endpoint, which defines how to connect to and communicate with external services.

EventLogConfigurationSummary

List of event log configurations.

ExponentialRolloutRate

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

LambdaConfig

Configuration details for an AWS Lambda function used as an endpoint for a cloud connector.

ManagedThingAssociation

Structure representing an association between a managed thing and an account association, which connects a device to a third-party account.

ManagedThingSchemaListItem

Structure representing one schema item associated with a managed thing.

ManagedThingSummary

Structure representing one managed thing.

MatterCapabilityReport

Matter based capability report.

MatterCapabilityReportAttribute

Matter attribute used in capability report.

MatterCapabilityReportCluster

Capability used in Matter capability report.

MatterCapabilityReportEndpoint

Matter endpoint used in capability report.

MatterCluster

Describe a Matter cluster with an id, and the relevant attributes, commands, and events.

MatterEndpoint

Structure describing a managed thing.

NotificationConfigurationSummary

Structure describing a notification configuration.

OAuthConfig

Configuration details for OAuth authentication with a third-party service.

OAuthUpdate

Structure containing updated OAuth configuration settings.

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.

ProactiveRefreshTokenRenewal

Configuration settings for proactively refreshing OAuth tokens before they expire.

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.

SecretsManager

Configuration for AWS Secrets Manager, used to securely store and manage sensitive information for connector destinations.

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.

AssociationState

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

AuthType

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

CloudConnectorType

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

ConnectorEventOperation

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

DiscoveryModification

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

EndpointType

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

TokenEndpointAuthenticationScheme

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