AWS.IoTFleetWise reference

AssociateVehicleFleet

Source: src/AWS/IoTFleetWise/AssociateVehicleFleet.ts

Runtime binding for the AssociateVehicleFleet operation (IAM action iotfleetwise:AssociateVehicleFleet), scoped to one Fleet.

Adds a vehicle to the bound fleet at runtime — e.g. a provisioning Lambda enrolling freshly-registered vehicles. Provide the implementation with Effect.provide(AWS.IoTFleetWise.AssociateVehicleFleetHttp).

AssociateVehicleFleet: Fleet Membership

const associateVehicleFleet = yield* IoTFleetWise.AssociateVehicleFleet(fleet);

yield* associateVehicleFleet({ vehicleName: "vin-1HGBH41JXMN109186" });

BatchCreateVehicle

Source: src/AWS/IoTFleetWise/BatchCreateVehicle.ts

Runtime binding for the BatchCreateVehicle operation (IAM action iotfleetwise:BatchCreateVehicle), account-level.

Creates up to 10 vehicles in one call — the data plane of vehicle provisioning pipelines (each item names its model and decoder manifest). Per-item failures are returned in the response errors list, not the error channel. Provide the implementation with Effect.provide(AWS.IoTFleetWise.BatchCreateVehicleHttp).

BatchCreateVehicle: Provisioning Vehicles

const batchCreateVehicle = yield* IoTFleetWise.BatchCreateVehicle();

const { vehicles, errors } = yield* batchCreateVehicle({
  vehicles: [
    {
      vehicleName: "vin-1HGBH41JXMN109186",
      modelManifestArn,
      decoderManifestArn,
    },
  ],
});

BatchUpdateVehicle

Source: src/AWS/IoTFleetWise/BatchUpdateVehicle.ts

Runtime binding for the BatchUpdateVehicle operation (IAM action iotfleetwise:BatchUpdateVehicle), account-level.

Updates up to 10 vehicles in one call — attributes, manifest associations, and state-template associations. Per-item failures are returned in the response errors list, not the error channel. Provide the implementation with Effect.provide(AWS.IoTFleetWise.BatchUpdateVehicleHttp).

BatchUpdateVehicle: Provisioning Vehicles

const batchUpdateVehicle = yield* IoTFleetWise.BatchUpdateVehicle();

yield* batchUpdateVehicle({
  vehicles: [
    {
      vehicleName: "vin-1HGBH41JXMN109186",
      attributes: { "Vehicle.Color": "red" },
      attributeUpdateMode: "Merge",
    },
  ],
});

Campaign

Source: src/AWS/IoTFleetWise/Campaign.ts

An AWS IoT FleetWise campaign — the orchestration of data-collection rules that the Edge Agent uses to decide which signals to collect from a Fleet or Vehicle and where to deliver them.

Campaigns are created in WAITING_FOR_APPROVAL status; set autoApprove: true to have the provider approve them into RUNNING. Only the description and extra dimensions are mutable — every other change replaces the campaign. AWS IoT FleetWise is allowlist-gated and offered in us-east-1/eu-central-1 only.

Campaign: Creating a Campaign

Time-Based Collection to S3

const campaign = yield* Campaign("SpeedTelemetry", {
  signalCatalogArn: catalog.signalCatalogArn,
  targetArn: fleet.fleetArn,
  collectionScheme: {
    timeBasedCollectionScheme: { period: "10 seconds" },
  },
  signalsToCollect: [{ name: "Vehicle.Speed" }],
  dataDestinationConfigs: [
    { s3Config: { bucketArn: bucket.bucketArn } },
  ],
  autoApprove: true,
});

Condition-Based Collection

const campaign = yield* Campaign("HardBraking", {
  signalCatalogArn: catalog.signalCatalogArn,
  targetArn: fleet.fleetArn,
  collectionScheme: {
    conditionBasedCollectionScheme: {
      expression: "$variable.`Vehicle.Speed` > 120.0",
      minimumTriggerInterval: "5 seconds",
      triggerMode: "RISING_EDGE",
    },
  },
  signalsToCollect: [
    { name: "Vehicle.Speed", minimumSamplingInterval: "500 millis" },
  ],
  postTriggerCollectionDuration: "30 seconds",
  dataDestinationConfigs: [
    { s3Config: { bucketArn: bucket.bucketArn } },
  ],
});

DecoderManifest

Source: src/AWS/IoTFleetWise/DecoderManifest.ts

An AWS IoT FleetWise decoder manifest — the decoding rules (network interfaces + signal decoders) that turn raw bus data from a vehicle modeled by a ModelManifest into standardized signals.

A manifest is created in DRAFT status; set status: "ACTIVE" to make it usable by vehicles. AWS IoT FleetWise is allowlist-gated and offered in us-east-1/eu-central-1 only.

DecoderManifest: Creating a Decoder Manifest

const decoder = yield* DecoderManifest("SedanDecoder", {
  modelManifestArn: model.modelManifestArn,
  networkInterfaces: [
    {
      interfaceId: "obd0",
      type: "OBD_INTERFACE",
      obdInterface: { name: "obd", requestMessageId: 2015 },
    },
  ],
  signalDecoders: [
    {
      fullyQualifiedName: "Vehicle.Speed",
      type: "OBD_SIGNAL",
      interfaceId: "obd0",
      obdSignal: {
        pidResponseLength: 1,
        serviceMode: 1,
        pid: 13,
        scaling: 1,
        offset: 0,
        startByte: 0,
        byteLength: 1,
      },
    },
  ],
  status: "ACTIVE",
});

DisassociateVehicleFleet

Source: src/AWS/IoTFleetWise/DisassociateVehicleFleet.ts

Runtime binding for the DisassociateVehicleFleet operation (IAM action iotfleetwise:DisassociateVehicleFleet), scoped to one Fleet.

Removes a vehicle from the bound fleet at runtime. Provide the implementation with Effect.provide(AWS.IoTFleetWise.DisassociateVehicleFleetHttp).

DisassociateVehicleFleet: Fleet Membership

const disassociateVehicleFleet =
  yield* IoTFleetWise.DisassociateVehicleFleet(fleet);

yield* disassociateVehicleFleet({ vehicleName: "vin-1HGBH41JXMN109186" });

Fleet

Source: src/AWS/IoTFleetWise/Fleet.ts

An AWS IoT FleetWise fleet — a group of vehicles that campaigns can target collectively.

Fleets are free, provisioned near-instantly, and only carry a description besides their signal-catalog association. AWS IoT FleetWise is allowlist-gated and offered in us-east-1/eu-central-1 only.

Fleet: Creating a Fleet

const fleet = yield* Fleet("TestFleet", {
  signalCatalogArn: catalog.signalCatalogArn,
  description: "west-coast pilot vehicles",
});

GetVehicleStatus

Source: src/AWS/IoTFleetWise/GetVehicleStatus.ts

Runtime binding for the GetVehicleStatus operation (IAM action iotfleetwise:GetVehicleStatus), scoped to one Vehicle.

Reads the deployment status of the campaigns, decoder manifests, and state templates associated with the bound vehicle. Provide the implementation with Effect.provide(AWS.IoTFleetWise.GetVehicleStatusHttp).

GetVehicleStatus: Vehicle Status

const getVehicleStatus = yield* IoTFleetWise.GetVehicleStatus(vehicle);

const status = yield* getVehicleStatus();
for (const campaign of status.campaigns ?? []) {
  console.log(campaign.campaignName, campaign.status);
}

ListDecoderManifestNetworkInterfaces

Source: src/AWS/IoTFleetWise/ListDecoderManifestNetworkInterfaces.ts

Runtime binding for the ListDecoderManifestNetworkInterfaces operation (IAM action iotfleetwise:ListDecoderManifestNetworkInterfaces), scoped to one DecoderManifest.

Lists the CAN/OBD/Ethernet network interfaces defined in the bound decoder manifest. Provide the implementation with Effect.provide(AWS.IoTFleetWise.ListDecoderManifestNetworkInterfacesHttp).

ListDecoderManifestNetworkInterfaces: Inspecting Signal Definitions

const listNetworkInterfaces =
  yield* IoTFleetWise.ListDecoderManifestNetworkInterfaces(decoder);

const { networkInterfaces } = yield* listNetworkInterfaces();

ListDecoderManifestSignals

Source: src/AWS/IoTFleetWise/ListDecoderManifestSignals.ts

Runtime binding for the ListDecoderManifestSignals operation (IAM action iotfleetwise:ListDecoderManifestSignals), scoped to one DecoderManifest.

Lists the signal decoders (CAN/OBD/message decoding rules) defined in the bound decoder manifest. Provide the implementation with Effect.provide(AWS.IoTFleetWise.ListDecoderManifestSignalsHttp).

ListDecoderManifestSignals: Inspecting Signal Definitions

const listDecoderSignals =
  yield* IoTFleetWise.ListDecoderManifestSignals(decoder);

const { signalDecoders } = yield* listDecoderSignals();

ListFleetsForVehicle

Source: src/AWS/IoTFleetWise/ListFleetsForVehicle.ts

Runtime binding for the ListFleetsForVehicle operation (IAM action iotfleetwise:ListFleetsForVehicle), scoped to one Vehicle.

Lists the IDs of the fleets the bound vehicle belongs to. Provide the implementation with Effect.provide(AWS.IoTFleetWise.ListFleetsForVehicleHttp).

ListFleetsForVehicle: Fleet Membership

const listFleetsForVehicle = yield* IoTFleetWise.ListFleetsForVehicle(vehicle);

const { fleets } = yield* listFleetsForVehicle();

ListModelManifestNodes

Source: src/AWS/IoTFleetWise/ListModelManifestNodes.ts

Runtime binding for the ListModelManifestNodes operation (IAM action iotfleetwise:ListModelManifestNodes), scoped to one ModelManifest.

Lists the signal nodes referenced by the bound vehicle model. Provide the implementation with Effect.provide(AWS.IoTFleetWise.ListModelManifestNodesHttp).

ListModelManifestNodes: Inspecting Signal Definitions

const listModelManifestNodes =
  yield* IoTFleetWise.ListModelManifestNodes(model);

const { nodes } = yield* listModelManifestNodes();

ListSignalCatalogNodes

Source: src/AWS/IoTFleetWise/ListSignalCatalogNodes.ts

Runtime binding for the ListSignalCatalogNodes operation (IAM action iotfleetwise:ListSignalCatalogNodes), scoped to one SignalCatalog.

Lists the branches, sensors, actuators, and attributes in the bound signal catalog. Provide the implementation with Effect.provide(AWS.IoTFleetWise.ListSignalCatalogNodesHttp).

ListSignalCatalogNodes: Inspecting Signal Definitions

const listSignalCatalogNodes =
  yield* IoTFleetWise.ListSignalCatalogNodes(catalog);

const { nodes } = yield* listSignalCatalogNodes({
  signalNodeType: "SENSOR",
});

ListVehicles

Source: src/AWS/IoTFleetWise/ListVehicles.ts

Runtime binding for the ListVehicles operation (IAM action iotfleetwise:ListVehicles), account-level.

Lists the vehicles in the account, optionally filtered by model manifest or attribute values. Provide the implementation with Effect.provide(AWS.IoTFleetWise.ListVehiclesHttp).

ListVehicles: Provisioning Vehicles

const listVehicles = yield* IoTFleetWise.ListVehicles();

const { vehicleSummaries } = yield* listVehicles({
  attributeNames: ["Vehicle.Color"],
  attributeValues: ["red"],
});

ListVehiclesInFleet

Source: src/AWS/IoTFleetWise/ListVehiclesInFleet.ts

Runtime binding for the ListVehiclesInFleet operation (IAM action iotfleetwise:ListVehiclesInFleet), scoped to one Fleet.

Lists the names of the vehicles associated with the bound fleet. Provide the implementation with Effect.provide(AWS.IoTFleetWise.ListVehiclesInFleetHttp).

ListVehiclesInFleet: Fleet Membership

const listVehiclesInFleet = yield* IoTFleetWise.ListVehiclesInFleet(fleet);

const { vehicles } = yield* listVehiclesInFleet();

ModelManifest

Source: src/AWS/IoTFleetWise/ModelManifest.ts

An AWS IoT FleetWise model manifest (vehicle model) — the subset of signal-catalog nodes that describes one vehicle type.

A manifest is created in DRAFT status; set status: "ACTIVE" to make it usable by decoder manifests and vehicles. AWS IoT FleetWise is allowlist-gated and offered in us-east-1/eu-central-1 only.

ModelManifest: Creating a Model Manifest

Active Vehicle Model

const model = yield* ModelManifest("SedanModel", {
  signalCatalogArn: catalog.signalCatalogArn,
  nodes: ["Vehicle.Speed"],
  status: "ACTIVE",
});

Draft Model with Description

const model = yield* ModelManifest("SedanModel", {
  signalCatalogArn: catalog.signalCatalogArn,
  nodes: ["Vehicle.Speed", "Vehicle.VIN"],
  description: "2026 sedan line",
});

SignalCatalog

Source: src/AWS/IoTFleetWise/SignalCatalog.ts

An AWS IoT FleetWise signal catalog — the account-wide collection of standardized vehicle signals (branches, sensors, actuators, attributes) that model manifests draw from.

AWS IoT FleetWise is offered in us-east-1 and eu-central-1 only; the provider follows the ambient region when supported and pins us-east-1 otherwise. Access to the service is allowlist-gated by AWS — accounts without access receive AccessDeniedException on every operation.

SignalCatalog: Creating a Signal Catalog

Catalog with a Branch and a Sensor

const catalog = yield* SignalCatalog("Signals", {
  nodes: [
    { branch: { fullyQualifiedName: "Vehicle" } },
    {
      sensor: {
        fullyQualifiedName: "Vehicle.Speed",
        dataType: "DOUBLE",
        unit: "km/h",
      },
    },
  ],
});

Catalog with Attributes

const catalog = yield* SignalCatalog("Signals", {
  description: "vehicle signals",
  nodes: [
    { branch: { fullyQualifiedName: "Vehicle" } },
    {
      attribute: {
        fullyQualifiedName: "Vehicle.VIN",
        dataType: "STRING",
      },
    },
  ],
  tags: { team: "telemetry" },
});

StateTemplate

Source: src/AWS/IoTFleetWise/StateTemplate.ts

An AWS IoT FleetWise state template — a definition of which signals’ last-known state the Edge Agent reports for a Vehicle (associated via the vehicle’s stateTemplates prop).

Only the description, tracked properties, and extra dimensions are mutable — changing the name or signal catalog replaces the template. AWS IoT FleetWise is allowlist-gated and offered in us-east-1/eu-central-1 only.

StateTemplate: Creating a State Template

Track Last-Known Speed

const template = yield* StateTemplate("SpeedState", {
  signalCatalogArn: catalog.signalCatalogArn,
  stateTemplateProperties: ["Vehicle.Speed"],
});

Associate with a Vehicle

const vehicle = yield* Vehicle("TestVehicle", {
  modelManifestArn: model.modelManifestArn,
  decoderManifestArn: decoder.decoderManifestArn,
  stateTemplates: [
    {
      identifier: template.stateTemplateName,
      stateTemplateUpdateStrategy: { onChange: {} },
    },
  ],
});

UpdateCampaign

Source: src/AWS/IoTFleetWise/UpdateCampaign.ts

Runtime binding for the UpdateCampaign operation (IAM action iotfleetwise:UpdateCampaign), scoped to one Campaign.

Approves, suspends, or resumes the bound campaign at runtime — e.g. an operations Lambda pausing data collection during an incident. Provide the implementation with Effect.provide(AWS.IoTFleetWise.UpdateCampaignHttp).

UpdateCampaign: Campaign Control

const updateCampaign = yield* IoTFleetWise.UpdateCampaign(campaign);

yield* updateCampaign({ action: "SUSPEND" });
yield* updateCampaign({ action: "RESUME" });

Vehicle

Source: src/AWS/IoTFleetWise/Vehicle.ts

An AWS IoT FleetWise vehicle — the digital twin of a physical vehicle, created from an ACTIVE ModelManifest and DecoderManifest pair and backed by an AWS IoT thing.

Vehicle: Creating a Vehicle

Vehicle with an Auto-Created IoT Thing

const vehicle = yield* Vehicle("TestVehicle", {
  modelManifestArn: model.modelManifestArn,
  decoderManifestArn: decoder.decoderManifestArn,
});

Vehicle with Attributes

const vehicle = yield* Vehicle("TestVehicle", {
  modelManifestArn: model.modelManifestArn,
  decoderManifestArn: decoder.decoderManifestArn,
  attributes: { "Vehicle.VIN": "1HGBH41JXMN109186" },
  tags: { plant: "fremont" },
});