AWS.IoTManagedIntegrations reference

CredentialLocker

Source: src/AWS/IoTManagedIntegrations/CredentialLocker.ts

An AWS IoT Managed Integrations credential locker — a secured store for the credentials that devices use to onboard and authenticate with Managed integrations.

IoT Managed Integrations is a regional service available in a limited set of regions (e.g. eu-west-1, ca-central-1).

CredentialLocker: Creating Credential Lockers

Basic Credential Locker

const locker = yield* CredentialLocker("DeviceCredentials", {});

Named Credential Locker with Tags

const locker = yield* CredentialLocker("DeviceCredentials", {
  name: "my-device-credentials",
  tags: { team: "iot" },
});

Destination

Source: src/AWS/IoTManagedIntegrations/Destination.ts

An AWS IoT Managed Integrations notification destination. Managed integrations delivers lifecycle events and device notifications to the destination (currently a Kinesis Data Stream) using the provided IAM role.

IoT Managed Integrations is a regional service available in a limited set of regions (e.g. eu-west-1, ca-central-1).

Destination: Creating Destinations

const stream = yield* Kinesis.Stream("Events", {});
const role = yield* IAM.Role("DeliveryRole", {
  assumeRolePolicyDocument: {
    Version: "2012-10-17",
    Statement: [
      {
        Effect: "Allow",
        Principal: { Service: "iotmanagedintegrations.amazonaws.com" },
        Action: ["sts:AssumeRole"],
      },
    ],
  },
});
const destination = yield* Destination("EventDestination", {
  deliveryDestinationArn: stream.streamArn,
  roleArn: role.roleArn,
  description: "Managed integrations device events",
});

GetCustomEndpoint

Source: src/AWS/IoTManagedIntegrations/GetCustomEndpoint.ts

Runtime binding for iotmanagedintegrations:GetCustomEndpoint (account-level).

Reads the account’s custom MQTT endpoint address — the address devices connect to for Managed integrations traffic. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.GetCustomEndpointHttp).

GetCustomEndpoint: Connectivity

const getCustomEndpoint = yield* IoTManagedIntegrations.GetCustomEndpoint();

const { EndpointAddress } = yield* getCustomEndpoint();

GetDeviceDiscovery

Source: src/AWS/IoTManagedIntegrations/GetDeviceDiscovery.ts

Runtime binding for iotmanagedintegrations:GetDeviceDiscovery (account-level).

Reads the status of a discovery scan started with StartDeviceDiscovery. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.GetDeviceDiscoveryHttp).

GetDeviceDiscovery: Discovering Devices

const getDiscovery = yield* IoTManagedIntegrations.GetDeviceDiscovery();

const { Status } = yield* getDiscovery({ Identifier: discoveryId });

GetManagedThingCapabilities

Source: src/AWS/IoTManagedIntegrations/GetManagedThingCapabilities.ts

Runtime binding for the GetManagedThingCapabilities operation (IAM action iotmanagedintegrations:GetManagedThingCapabilities), scoped to one ManagedThing.

Reads the capability report the bound device registered at onboarding — the data model that SendManagedThingCommand commands are written against. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.GetManagedThingCapabilitiesHttp).

GetManagedThingCapabilities: Reading Device State

const getCapabilities =
  yield* IoTManagedIntegrations.GetManagedThingCapabilities(thing);

const { CapabilityReport } = yield* getCapabilities();
// CapabilityReport?.endpoints[0].capabilities

GetManagedThingCertificate

Source: src/AWS/IoTManagedIntegrations/GetManagedThingCertificate.ts

Runtime binding for the GetManagedThingCertificate operation (IAM action iotmanagedintegrations:GetManagedThingCertificate), scoped to one ManagedThing.

Reads the (public) certificate PEM the bound device authenticates with — useful for fleet audit and certificate-rotation tooling. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.GetManagedThingCertificateHttp).

GetManagedThingCertificate: Reading Device State

const getCertificate =
  yield* IoTManagedIntegrations.GetManagedThingCertificate(thing);

const { CertificatePem } = yield* getCertificate();

GetManagedThingConnectivityData

Source: src/AWS/IoTManagedIntegrations/GetManagedThingConnectivityData.ts

Runtime binding for the GetManagedThingConnectivityData operation (IAM action iotmanagedintegrations:GetManagedThingConnectivityData), scoped to one ManagedThing.

Reads whether the bound device is currently connected, when its connectivity last changed, and the disconnect reason if offline. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.GetManagedThingConnectivityDataHttp).

GetManagedThingConnectivityData: Reading Device State

const getConnectivity =
  yield* IoTManagedIntegrations.GetManagedThingConnectivityData(thing);

const { Connected, DisconnectReason } = yield* getConnectivity();

GetManagedThingMetaData

Source: src/AWS/IoTManagedIntegrations/GetManagedThingMetaData.ts

Runtime binding for the GetManagedThingMetaData operation (IAM action iotmanagedintegrations:GetManagedThingMetaData), scoped to one ManagedThing.

Reads the metadata key-value pairs attached to the bound managed thing. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.GetManagedThingMetaDataHttp).

GetManagedThingMetaData: Reading Device State

const getMetaData =
  yield* IoTManagedIntegrations.GetManagedThingMetaData(thing);

const { MetaData } = yield* getMetaData();

GetManagedThingState

Source: src/AWS/IoTManagedIntegrations/GetManagedThingState.ts

Runtime binding for the GetManagedThingState operation (IAM action iotmanagedintegrations:GetManagedThingState), scoped to one ManagedThing.

Reads the last-reported state of every endpoint/capability of the bound device (e.g. whether a smart plug is on). Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.GetManagedThingStateHttp).

GetManagedThingState: Reading Device State

const getState = yield* IoTManagedIntegrations.GetManagedThingState(thing);

const { Endpoints } = yield* getState();
// Endpoints[0].capabilities[0].properties

GetSchemaVersion

Source: src/AWS/IoTManagedIntegrations/GetSchemaVersion.ts

Runtime binding for iotmanagedintegrations:GetSchemaVersion (account-level).

Reads one version of a capability or definition schema from the Managed integrations schema catalog — the vocabulary that device data models and commands are expressed in. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.GetSchemaVersionHttp).

GetSchemaVersion: Working with the Schema Catalog

const getSchemaVersion = yield* IoTManagedIntegrations.GetSchemaVersion();

const { Schema } = yield* getSchemaVersion({
  Type: "capability",
  SchemaVersionedId: "matter.OnOff@1.4",
});

ListDeviceDiscoveries

Source: src/AWS/IoTManagedIntegrations/ListDeviceDiscoveries.ts

Runtime binding for iotmanagedintegrations:ListDeviceDiscoveries (account-level).

Lists the discovery scans in the account, optionally filtered by type or status — useful for finding a running scan before polling it with GetDeviceDiscovery. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.ListDeviceDiscoveriesHttp).

ListDeviceDiscoveries: Discovering Devices

const listDiscoveries = yield* IoTManagedIntegrations.ListDeviceDiscoveries();

const { Items } = yield* listDiscoveries({ StatusFilter: "RUNNING" });

ListDiscoveredDevices

Source: src/AWS/IoTManagedIntegrations/ListDiscoveredDevices.ts

Runtime binding for iotmanagedintegrations:ListDiscoveredDevices (account-level).

Lists the devices found by a discovery scan, including the managed thing id assigned to each already-onboarded device. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.ListDiscoveredDevicesHttp).

ListDiscoveredDevices: Discovering Devices

const listDiscovered = yield* IoTManagedIntegrations.ListDiscoveredDevices();

const { Items } = yield* listDiscovered({ Identifier: discoveryId });

ListManagedThingSchemas

Source: src/AWS/IoTManagedIntegrations/ListManagedThingSchemas.ts

Runtime binding for the ListManagedThingSchemas operation (IAM action iotmanagedintegrations:ListManagedThingSchemas), scoped to one ManagedThing.

Lists the capability schemas of the bound device, optionally filtered by endpoint or capability id. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.ListManagedThingSchemasHttp).

ListManagedThingSchemas: Reading Device State

const listSchemas =
  yield* IoTManagedIntegrations.ListManagedThingSchemas(thing);

const { Items } = yield* listSchemas({ EndpointIdFilter: "1" });

ListSchemaVersions

Source: src/AWS/IoTManagedIntegrations/ListSchemaVersions.ts

Runtime binding for iotmanagedintegrations:ListSchemaVersions (account-level).

Lists capability or definition schema versions in the Managed integrations schema catalog, optionally filtered by namespace, schema id, visibility, or semantic version. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.ListSchemaVersionsHttp).

ListSchemaVersions: Working with the Schema Catalog

const listSchemaVersions = yield* IoTManagedIntegrations.ListSchemaVersions();

const { Items } = yield* listSchemaVersions({
  Type: "capability",
  Namespace: "matter",
});

ManagedThing

Source: src/AWS/IoTManagedIntegrations/ManagedThing.ts

An AWS IoT Managed Integrations managed thing — the cloud representation of a device (or controller) onboarded through Managed integrations, carrying its identity, protocol, and capability data model.

Creating a managed thing requires real device onboarding material (e.g. a Wi-Fi Simple Setup or Zigbee QR bar code payload). IoT Managed Integrations is a regional service available in a limited set of regions (e.g. eu-west-1, ca-central-1).

ManagedThing: Creating Managed Things

Controller from a Wi-Fi Setup QR Code

const thing = yield* ManagedThing("Hub", {
  role: "CONTROLLER",
  authenticationMaterial: Redacted.make(wifiSetupQrCodePayload),
  authenticationMaterialType: "WIFI_SETUP_QR_BAR_CODE",
});

Device with a Credential Locker

const locker = yield* CredentialLocker("DeviceCredentials", {});
const thing = yield* ManagedThing("Sensor", {
  role: "DEVICE",
  authenticationMaterial: Redacted.make(zigbeeQrCodePayload),
  authenticationMaterialType: "ZIGBEE_QR_BAR_CODE",
  credentialLockerId: locker.credentialLockerId,
  serialNumber: "SN-0001",
});

NotificationConfiguration

Source: src/AWS/IoTManagedIntegrations/NotificationConfiguration.ts

An AWS IoT Managed Integrations notification configuration — routes one event type (device state, lifecycle, OTA, discovery, association events) to a Destination.

Managed integrations has no direct Lambda invocation path: events flow NotificationConfiguration -> Destination -> Kinesis Data Stream, so pair this resource with a Kinesis-backed destination and consume the stream with the Kinesis stream event source (Kinesis.consumeStreamRecords).

IoT Managed Integrations is a regional service available in a limited set of regions (e.g. eu-west-1, ca-central-1).

NotificationConfiguration: Routing Events

Route Device State Events to a Kinesis Destination

const destination = yield* Destination("EventDestination", {
  deliveryDestinationArn: stream.streamArn,
  roleArn: role.roleArn,
});
const routing = yield* NotificationConfiguration("DeviceState", {
  eventType: "DEVICE_STATE",
  destinationName: destination.destinationName,
});

Route Lifecycle Events with Tags

const routing = yield* NotificationConfiguration("Lifecycle", {
  eventType: "DEVICE_LIFE_CYCLE",
  destinationName: destination.destinationName,
  tags: { team: "iot" },
});

SendConnectorEvent

Source: src/AWS/IoTManagedIntegrations/SendConnectorEvent.ts

Runtime binding for iotmanagedintegrations:SendConnectorEvent (account-level).

The cloud-to-cloud connector data plane: a connector Lambda calls this to push third-party device events (state reports, discovery results, command responses) into Managed integrations. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.SendConnectorEventHttp).

SendConnectorEvent: Connectors

const sendConnectorEvent = yield* IoTManagedIntegrations.SendConnectorEvent();

yield* sendConnectorEvent({
  ConnectorId: connectorId,
  Operation: "DEVICE_EVENT",
  ConnectorDeviceId: "third-party-device-1",
  Devices: [
    {
      ConnectorDeviceId: "third-party-device-1",
      CapabilityReport: capabilityReport,
    },
  ],
});

SendManagedThingCommand

Source: src/AWS/IoTManagedIntegrations/SendManagedThingCommand.ts

Runtime binding for the SendManagedThingCommand operation (IAM action iotmanagedintegrations:SendManagedThingCommand), scoped to one ManagedThing.

Sends a command to the bound device using its Matter-derived capability data model — the primary control-plane-to-device data path. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.SendManagedThingCommandHttp).

SendManagedThingCommand: Controlling Devices

const sendCommand = yield* IoTManagedIntegrations.SendManagedThingCommand(thing);

const { TraceId } = yield* sendCommand({
  Endpoints: [
    {
      endpointId: "1",
      capabilities: [
        {
          id: "aws.OnOff",
          name: "On/Off",
          version: "1",
          actions: [{ name: "activate", actionTraceId: "req-1" }],
        },
      ],
    },
  ],
});

StartDeviceDiscovery

Source: src/AWS/IoTManagedIntegrations/StartDeviceDiscovery.ts

Runtime binding for iotmanagedintegrations:StartDeviceDiscovery (account-level).

Starts a discovery scan for devices reachable through a controller (ZWAVE/ZIGBEE), a cloud-to-cloud connector (CLOUD), or a custom protocol. Provide the implementation with Effect.provide(AWS.IoTManagedIntegrations.StartDeviceDiscoveryHttp).

StartDeviceDiscovery: Discovering Devices

// init — account-level binding takes no resource
const startDiscovery = yield* IoTManagedIntegrations.StartDeviceDiscovery();

// runtime
const { Id } = yield* startDiscovery({
  DiscoveryType: "ZIGBEE",
  ControllerIdentifier: controllerManagedThingId,
});