fleetpull 0.1.0__py3-none-any.whl

fleetpull/models/samsara/idling_event.py

@@ -0,0 +1,174 @@
+# src/fleetpull/models/samsara/idling_event.py
+"""Samsara IdlingEvent response model (``GET /idling/events``).
+
+Written from captured live responses (2026-07-20 probe session: a
+2,200-event census walked over 11 cursor pages), never from docs. The
+census observed ZERO real nulls -- optionality is absence-shaped
+(Samsara omits keys, the vehicles/drivers posture): every key below
+except the three partial blocks was present on every record, so those
+fields are required; ``operator`` (1546/2200 -- driver attribution when
+known), ``airTemperatureMillicelsius`` (1833/2200), and ``address``
+(552/2200) are optional. Within a carrying ``address`` block,
+``addressTypes`` is itself absent on ~31 of the 552 blocks, so it is
+optional inside the block too.
+
+There is NO end key: the interval is start plus duration. Events were
+only ever observed complete, with implied ends in the past even in a
+last-30-minutes probe -- in-progress idles appear to materialize on
+completion; the watermark lookback absorbs late materialization
+(accepted residual, DESIGN §8). ``durationMilliseconds`` stays a
+verbatim unit-suffixed int mirror -- no timedelta recovery: the value
+is directly consumable, and recovery would presume a use.
+
+``startTime`` is an RFC3339 string recovered as a tz-aware UTC datetime
+by Pydantic's standard parse (the vehicles/drivers pattern, NOT the
+trips epoch-ms path). ``ptoState`` is a plain ``str``, NOT an enum:
+only ``'inactive'`` was observed in 2,200 records, but the value set is
+not closed by evidence (unlike ``driverActivationStatus``'s 400-proven
+closure), so membership is not enforced. ``fuelConsumedMilliliters`` is
+MIXED int|float on the wire -- modeled ``float``, lax coercion lifting
+the int shape. The two money blocks mirror verbatim as strings
+(``{amount, currency}``) -- never parsed to a numeric type. NOTE the id
+type split, mirrored exactly: ``address.id`` is a STRING while
+``asset.id`` and ``operator.id`` are BARE INTs.
+
+Wire keys are camelCase; fields are snake_case via the ``to_camel``
+alias generator.
+"""
+
+from datetime import datetime
+
+from pydantic import ConfigDict
+from pydantic.alias_generators import to_camel
+
+from fleetpull.model_contract import ResponseModel
+
+__all__: list[str] = [
+    'AssetRef',
+    'FuelCost',
+    'IdlingAddress',
+    'IdlingEvent',
+    'OperatorRef',
+]
+
+
+class AssetRef(ResponseModel):
+    """The ``asset`` block: the event's vehicle reference.
+
+    Present on every captured record -- events are fleet-wide with
+    per-record asset attribution, which is what makes the endpoint a
+    single fetch with no fan-out.
+
+    Attributes:
+        id: Samsara's asset id -- a BARE int on the wire, unlike the
+            numeric-string ids of the vehicles/drivers surfaces.
+    """
+
+    id: int
+
+
+class OperatorRef(ResponseModel):
+    """The ``operator`` block: driver attribution when known (1546/2200).
+
+    Attributes:
+        id: Samsara's operator id -- a BARE int on the wire, like
+            ``asset.id``.
+    """
+
+    id: int
+
+
+class IdlingAddress(ResponseModel):
+    """The ``address`` block: a matched defined-address reference (552/2200).
+
+    Attributes:
+        id: Samsara's address id -- a STRING on the wire, unlike the
+            bare-int ``asset.id``/``operator.id`` beside it (mirrored
+            exactly; never coerced to match its siblings).
+        address_types: The defined address's type tags (element
+            ``'yard'`` observed); absent on ~31 of the 552 captured
+            address blocks, so optional within the block.
+    """
+
+    model_config = ConfigDict(alias_generator=to_camel)
+
+    id: str
+    address_types: list[str] | None = None
+
+
+class FuelCost(ResponseModel):
+    """A money block: the ``{amount, currency}`` shape.
+
+    The one shape both cost fields (``fuelCost``, ``gaseousFuelCost``)
+    carry, both keys present in every captured block. Mirrored verbatim
+    as strings -- parsing money would presume a use.
+
+    Attributes:
+        amount: The monetary amount, a decimal string.
+        currency: The currency code string.
+    """
+
+    amount: str
+    currency: str
+
+
+class IdlingEvent(ResponseModel):
+    """One Samsara idling event, start-anchored per window.
+
+    A pure mirror of the captured fields (module docstring). Field
+    semantics and units are Samsara's; no value is derived or
+    interpreted here. The interval is ``start_time`` plus
+    ``duration_milliseconds`` -- there is no end key on the wire.
+
+    Attributes:
+        event_uuid: The event's id, a UUID string.
+        start_time: Idle start (RFC3339, recovered tz-aware UTC) -- the
+            endpoint's event time; retrieval is START-anchored on UTC
+            (DESIGN §8), so retrieval and routing coincide natively.
+        duration_milliseconds: Idle duration in milliseconds, a bare
+            int mirrored verbatim (no end key exists; module
+            docstring).
+        asset: The vehicle reference (bare-int id).
+        latitude: Event latitude, decimal degrees.
+        longitude: Event longitude, decimal degrees.
+        pto_state: Power-take-off state -- a plain string; only
+            ``'inactive'`` observed in 2,200 records, but the value set
+            is not evidence-closed, so no enum (module docstring).
+        fuel_consumed_milliliters: Fuel consumed while idling, in
+            milliliters -- MIXED int|float on the wire, modeled float.
+        fuel_cost: The fuel cost money block, strings verbatim.
+        gaseous_fuel_consumed_grams: Gaseous fuel consumed, in grams, a
+            bare int.
+        gaseous_fuel_cost: The gaseous-fuel cost money block, strings
+            verbatim.
+        operator: Driver attribution when known (1546/2200; bare-int
+            id).
+        air_temperature_millicelsius: Ambient air temperature in
+            millidegrees Celsius, a bare int (1833/2200).
+        address: The matched defined-address block (552/2200; STRING
+            id).
+    """
+
+    model_config = ConfigDict(alias_generator=to_camel)
+
+    # Identity and the start+duration interval (no end key).
+    event_uuid: str
+    start_time: datetime
+    duration_milliseconds: int
+
+    # Attribution and position.
+    asset: AssetRef
+    latitude: float
+    longitude: float
+
+    # State and consumption (provider units mirrored verbatim).
+    pto_state: str
+    fuel_consumed_milliliters: float
+    fuel_cost: FuelCost
+    gaseous_fuel_consumed_grams: int
+    gaseous_fuel_cost: FuelCost
+
+    # The partial blocks (absence-shaped).
+    operator: OperatorRef | None = None
+    air_temperature_millicelsius: int | None = None
+    address: IdlingAddress | None = None

fleetpull/models/samsara/odometer_reading.py

@@ -0,0 +1,90 @@
+# src/fleetpull/models/samsara/odometer_reading.py
+"""Samsara OdometerReading response model
+(``GET /fleet/vehicles/stats/history``, ``types=obdOdometerMeters``,
+post-decoder reading grain).
+
+Written from captured live responses (2026-07-20 probe session: a
+9,480-reading census over a 24-hour window, 135 vehicles -- every
+vehicle returned per the requested type carried data; no empty-array
+padding was observed), never from docs. The model mirrors the FLAT
+record ``SamsaraVehicleSeriesPageDecoder`` emits, one row per reading
+-- the grain the records pipeline represents (scalars, not
+list-of-objects; DESIGN section 9) -- and its two field families have
+different provenance:
+
+- ``vehicle_id`` / ``vehicle_name`` / ``vehicle_serial`` /
+  ``vehicle_vin`` are DECODER-SYNTHESIZED: the unnesting lifts them
+  from the per-vehicle ``id``/``name`` keys and the ``externalIds``
+  object's literal dotted ``samsara.serial``/``samsara.vin`` wire keys
+  onto every reading. ``vehicle_id`` and ``vehicle_name`` were 74/74
+  on the censused mixed-type page and are required; ``vehicle_serial``
+  and ``vehicle_vin`` were also 74/74 there, but one page is not a
+  whole-population oath (an unplugged or serial-less unit could omit
+  its ``externalIds`` block -- the vehicles surface shows exactly that
+  variance), so both stay OPTIONAL -- the drivers conservative posture.
+- ``time`` / ``value`` are WIRE-VERBATIM reading keys: the series
+  census observed exactly ``{time, value}`` on every one of the 9,480
+  readings, so both are required.
+
+``value`` is the OBD odometer in METERS -- a bare int on every observed
+reading (range 3,552,000..1,012,456,215 in census), mirrored verbatim
+under the model's unitless wire name; the unit lives here and in the
+series' stat-type name (``obdOdometerMeters``), never converted.
+
+``time`` is an RFC3339 string recovered as a tz-aware UTC datetime by
+Pydantic's standard parse. Readings fall strictly inside the requested
+``[startTime, endTime)`` window (probe-proven), so ``time`` is the
+endpoint's event-time column with retrieval and routing coinciding
+natively.
+
+Wire keys are camelCase; fields are snake_case via the ``to_camel``
+alias generator.
+"""
+
+from datetime import datetime
+
+from pydantic import ConfigDict
+from pydantic.alias_generators import to_camel
+
+from fleetpull.model_contract import ResponseModel
+
+__all__: list[str] = ['OdometerReading']
+
+
+class OdometerReading(ResponseModel):
+    """One OBD odometer reading of one vehicle, at the reading grain.
+
+    A pure mirror of the flat post-decoder record (module docstring:
+    the identity fields are decoder-synthesized, the reading fields
+    wire-verbatim). Field semantics and units are Samsara's; no value
+    is derived or interpreted here.
+
+    Attributes:
+        vehicle_id: The vehicle's Samsara id -- a numeric string,
+            decoder-synthesized from the vehicle record's ``id``.
+        vehicle_name: The vehicle's display name, decoder-synthesized
+            from the vehicle record's ``name``.
+        vehicle_serial: The gateway serial, decoder-synthesized from
+            ``externalIds['samsara.serial']`` (74/74 on the censused
+            page; optional -- module docstring).
+        vehicle_vin: The VIN, decoder-synthesized from
+            ``externalIds['samsara.vin']`` (74/74 on the censused page;
+            optional -- module docstring).
+        time: The reading instant (RFC3339, recovered tz-aware UTC) --
+            the event-time column; readings fall strictly inside the
+            requested window.
+        value: The OBD odometer in meters -- a bare int on every
+            observed reading, mirrored verbatim (module docstring).
+    """
+
+    model_config = ConfigDict(alias_generator=to_camel)
+
+    # Decoder-synthesized vehicle identity.
+    vehicle_id: str
+    vehicle_name: str
+    vehicle_serial: str | None = None
+    vehicle_vin: str | None = None
+
+    # Wire-verbatim reading payload.
+    time: datetime
+    value: int

fleetpull/models/samsara/trip.py

@@ -0,0 +1,199 @@
+# src/fleetpull/models/samsara/trip.py
+"""Samsara Trip response model (``GET /v1/fleet/trips`` -- the legacy v1
+surface; every modern candidate path 404s).
+
+Written from captured live responses (2026-07-20 probe session: a
+725-trip census across 60 vehicles), never from docs. The census
+observed ZERO nulls anywhere: every key below except the two address
+blocks was present on every record, so those fields are required; the
+address blocks (``startAddress`` 177/725, ``endAddress`` 185/725) are
+present only when the trip endpoint matched a defined address/geofence
+and are optional.
+
+``startMs``/``endMs`` are epoch-MILLISECOND ints on the wire. The
+mirror RECOVERS them as tz-aware UTC datetimes via a mode='before'
+validator -- type recovery is structural and belongs on the mirror (the
+``GeotabTimeSpan`` precedent), not interpretation. The field names
+(``start_time``/``end_time``) drop the wire's unit suffix because the
+recovered type carries the unit; naming is the model's to own. ``endMs``
+was present on every observed trip including the two most recent --
+in-progress trips were never observed and appear to materialize on
+completion; the watermark lookback absorbs late materialization
+(accepted residual, DESIGN §8), so ``end_time`` stays required and a
+trip ever arriving without it fails validation loudly.
+
+Everything else mirrors verbatim: the unit-suffixed int family
+(``distanceMeters``, ``fuelConsumedMl``, ``tollMeters``) and the
+odometer pair keep provider units untouched; ``driverId`` is an int
+whose ``0`` is the UNASSIGNED sentinel (110/725) -- mirrored verbatim,
+never nulled or interpreted. ``assetIds``/``codriverIds`` were observed
+ONLY EMPTY across all 725 records; they are typed ``list[int]`` --
+the int-id family, in the ``list[scalar]`` form the records layer's
+schema derivation represents (DESIGN §9; the §9 pipeline has no tuple
+form) -- so a first non-empty capture lands as data, not a crash.
+
+The record does NOT echo the requested ``vehicleId``: per-vehicle
+attribution lives in the request parameter (the roster fan-out member),
+not on the wire record. The response *wrapper* (the ``{"trips": [...]}``
+envelope, unpaginated) is the endpoints layer's decoder concern; this
+module mirrors only the inner per-trip object.
+
+Wire keys are camelCase; fields are snake_case via the ``to_camel``
+alias generator (``startMs``/``endMs`` carry explicit aliases, since
+their field names diverge by design).
+"""
+
+from datetime import UTC, datetime, timedelta
+from typing import Annotated, Final
+
+from pydantic import BeforeValidator, ConfigDict, Field
+from pydantic.alias_generators import to_camel
+
+from fleetpull.model_contract import ResponseModel
+from fleetpull.vocabulary import JsonValue
+
+__all__: list[str] = [
+    'Trip',
+    'TripAddress',
+    'TripCoordinates',
+]
+
+_EPOCH_START: Final[datetime] = datetime(1970, 1, 1, tzinfo=UTC)
+
+
+def _epoch_milliseconds_to_datetime(value: JsonValue | datetime) -> datetime:
+    """The epoch-ms ingress: recover a tz-aware UTC datetime from a wire int.
+
+    Strict by design: the census observed BARE ints only, so anything
+    else -- a quoted number, a float, a bool -- is a wire drift that
+    should fail validation loudly, not pass mangled. Exact integer
+    arithmetic (no float epoch math), so millisecond precision is
+    preserved verbatim.
+
+    Args:
+        value: The raw wire value, or an already-recovered datetime on a
+            Pydantic revalidation path.
+
+    Returns:
+        The instant as a timezone-aware UTC datetime (passthrough for an
+        already-recovered value).
+
+    Raises:
+        ValueError: ``value`` is not a bare int (bools excluded).
+    """
+    if isinstance(value, datetime):
+        return value
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ValueError(
+            f'expected a bare epoch-millisecond int, got {type(value).__name__}'
+        )
+    return _EPOCH_START + timedelta(milliseconds=value)
+
+
+# The epoch-ms datetime field type. Plain assignment, not a `type`
+# statement: Pydantic must evaluate the Annotated form eagerly so the
+# metadata lifts into FieldInfo and the records field walk sees the bare
+# `datetime` leaf (the GeotabTimeSpan stance).
+_EpochMillisecondsDatetime = Annotated[
+    datetime, BeforeValidator(_epoch_milliseconds_to_datetime)
+]
+
+
+class TripCoordinates(ResponseModel):
+    """A ``{latitude, longitude}`` coordinate pair, decimal-degree floats.
+
+    The one shape both trip endpoints' coordinate blocks
+    (``startCoordinates``, ``endCoordinates``) carry -- both keys
+    present in every captured block.
+    """
+
+    latitude: float
+    longitude: float
+
+
+class TripAddress(ResponseModel):
+    """A matched address/geofence block: the ``{address, id, name}`` shape.
+
+    Present only when a trip endpoint matched a defined address/geofence
+    (``startAddress`` 177/725, ``endAddress`` 185/725); all three keys
+    present in every carrying block.
+
+    Attributes:
+        address: The defined address's street address string.
+        id: Samsara's address id -- a BARE int on the wire, unlike the
+            string ids of the vehicles/drivers surfaces.
+        name: The defined address's display name.
+    """
+
+    address: str
+    id: int
+    name: str
+
+
+class Trip(ResponseModel):
+    """One Samsara vehicle trip, overlap-retrieved per (vehicle, window).
+
+    A pure mirror of the captured fields (module docstring). Field
+    semantics and units are Samsara's; no value is derived or
+    interpreted here. The requested ``vehicleId`` is not echoed on the
+    record.
+
+    Attributes:
+        start_time: Trip start, recovered from the wire's epoch-ms
+            ``startMs`` -- the endpoint's event time (start-anchored
+            ownership, DESIGN §4).
+        end_time: Trip end, recovered from the wire's epoch-ms
+            ``endMs``; present on every observed trip (in-progress trips
+            appear to materialize on completion).
+        distance_meters: Trip distance in meters, a bare int.
+        fuel_consumed_ml: Fuel consumed in milliliters, a bare int.
+        toll_meters: Distance on toll roads in meters, a bare int.
+        start_odometer: Odometer at trip start -- provider units
+            mirrored verbatim, a bare int.
+        end_odometer: Odometer at trip end -- provider units mirrored
+            verbatim, a bare int.
+        driver_id: The assigned driver's id; ``0`` is the UNASSIGNED
+            sentinel (110/725), mirrored verbatim.
+        start_location: Reverse-geocoded start location string.
+        end_location: Reverse-geocoded end location string.
+        start_coordinates: The start ``{latitude, longitude}`` block.
+        end_coordinates: The end ``{latitude, longitude}`` block.
+        asset_ids: Attached asset ids; observed ONLY EMPTY across all
+            725 census records.
+        codriver_ids: Co-driver ids; observed ONLY EMPTY across all 725
+            census records.
+        start_address: The matched start address/geofence block
+            (177/725); null when no defined address matched.
+        end_address: The matched end address/geofence block (185/725);
+            null when no defined address matched.
+    """
+
+    model_config = ConfigDict(alias_generator=to_camel)
+
+    # The trip interval (epoch-ms recovered, module docstring).
+    start_time: _EpochMillisecondsDatetime = Field(alias='startMs')
+    end_time: _EpochMillisecondsDatetime = Field(alias='endMs')
+
+    # Distances, fuel, and odometers (provider units, bare ints).
+    distance_meters: int
+    fuel_consumed_ml: int
+    toll_meters: int
+    start_odometer: int
+    end_odometer: int
+
+    # Assignment (0 = unassigned, mirrored verbatim).
+    driver_id: int
+
+    # Endpoints: geocoded strings and coordinate blocks.
+    start_location: str
+    end_location: str
+    start_coordinates: TripCoordinates
+    end_coordinates: TripCoordinates
+
+    # The int-id lists (only empties observed).
+    asset_ids: list[int]
+    codriver_ids: list[int]
+
+    # The partial address/geofence matches.
+    start_address: TripAddress | None = None
+    end_address: TripAddress | None = None

fleetpull/models/samsara/vehicle.py

@@ -0,0 +1,167 @@
+# src/fleetpull/models/samsara/vehicle.py
+"""Samsara Vehicle response model (``GET /fleet/vehicles``).
+
+Written from captured live responses (2026-07-17 probe session: a
+full-population sweep of all 608 records plus six captured record
+variants), never from docs. The sweep observed no null value and no
+type variance on any of the 20 observed keys -- Samsara omits absent
+keys rather than nulling them (the GeoTab posture), while also using
+empty strings (``notes: ""`` on every captured record), which mirror
+verbatim and normalize to null at the DataFrame boundary. Fields the
+sweep proved on every record are required; the partial-presence fields
+are optional (presence counts in the attribute docs, out of 608). The
+minimal captured shape is the bare 7-key form -- units with no gateway
+carry serial-shaped default names.
+
+``year`` arrives as a quoted integer (``"2013"``); lax coercion types
+it. No empty-string ``year`` was observed in 608 records -- if one ever
+arrives, the loud ``int_parsing`` failure names it (the Motive ``year``
+history, replayed on purpose).
+
+Excluded fields (``extra='ignore'`` makes exclusion exactly "don't
+model it"):
+
+- ``tags`` -- a list of ``{id, name, parentTagId}`` objects (549/608,
+  ``parentTagId`` itself partial within elements); the records layer's
+  schema derivation supports scalars, enums, ``list[scalar]``, and
+  nested models only (the Device/User exclusion precedent) -- modeled
+  when the list-of-structs derivation vertical lands.
+
+``externalIds`` is an OPEN, user-definable map whose keys are dotted
+namespace names -- not a struct. The two Samsara-managed keys observed
+in every carrying record are modeled as aliased fields
+(``samsara.serial``, ``samsara.vin``, each mirroring its top-level
+sibling exactly in capture); user-defined keys are absorbed by
+``extra='ignore'`` until a capture shows one, per the union-of-observed
+discipline.
+
+Wire keys are camelCase; fields are snake_case via the ``to_camel``
+alias generator (the dotted ``externalIds`` keys carry explicit
+aliases, above the generator's reach).
+"""
+
+from datetime import datetime
+
+from pydantic import ConfigDict, Field
+from pydantic.alias_generators import to_camel
+
+from fleetpull.model_contract import ResponseModel
+
+__all__: list[str] = [
+    'Vehicle',
+    'VehicleExternalIds',
+    'VehicleGatewayRef',
+    'VehicleStaticAssignedDriverRef',
+]
+
+
+class VehicleExternalIds(ResponseModel):
+    """The ``externalIds`` block: an open map of namespaced external ids.
+
+    Only the two Samsara-managed keys are modeled (see the module
+    docstring's open-map caveat). Each key is independently optional --
+    the sweep observed carriers with a serial and no VIN (595 blocks:
+    ``samsara.serial`` on 509, ``samsara.vin`` on 576).
+
+    Attributes:
+        samsara_serial: The gateway serial, undashed (wire key
+            ``samsara.serial``; equal to the record's top-level
+            ``serial`` in every capture).
+        samsara_vin: The VIN (wire key ``samsara.vin``; equal to the
+            record's top-level ``vin`` in every capture).
+    """
+
+    samsara_serial: str | None = Field(default=None, alias='samsara.serial')
+    samsara_vin: str | None = Field(default=None, alias='samsara.vin')
+
+
+class VehicleGatewayRef(ResponseModel):
+    """The installed telematics gateway: serial and hardware model.
+
+    Attributes:
+        serial: The gateway serial in Samsara's dashed 4-3-3 rendering
+            (the record's top-level ``serial`` carries the undashed
+            form of the same value in every capture).
+        model: The gateway hardware model (``"VG34"`` captured).
+    """
+
+    serial: str
+    model: str
+
+
+class VehicleStaticAssignedDriverRef(ResponseModel):
+    """The statically assigned driver reference: id and display name."""
+
+    id: str
+    name: str
+
+
+class Vehicle(ResponseModel):
+    """One Samsara fleet vehicle.
+
+    A pure mirror of the captured fields (``tags`` excluded, module
+    docstring). Field semantics are Samsara's; no value is derived or
+    interpreted here.
+
+    Attributes:
+        id: Samsara's vehicle id -- a numeric string, mirrored as
+            string.
+        name: The unit's display name; units with no gateway carry
+            serial-shaped default names (captured).
+        notes: Free-form notes; ``""`` on every captured record,
+            mirrored verbatim.
+        harsh_acceleration_setting_type: Settings vocabulary
+            (``"automatic"`` captured), mirrored, never interpreted.
+        vehicle_regulation_mode: ``"regulated"`` / ``"unregulated"``
+            captured, mirrored, never interpreted.
+        created_at_time: Record creation (UTC).
+        updated_at_time: Last record update (UTC).
+        camera_serial: Dash-cam serial, dashed rendering (404/608).
+        external_ids: The open external-id map's modeled slice
+            (595/608).
+        gateway: The installed gateway reference (509/608; absent on
+            unplugged units -- the minimal shape).
+        serial: The gateway serial, undashed (509/608; the dashed twin
+            lives on ``gateway.serial``).
+        esn: Electronic serial number; both captured shapes are
+            alphanumeric strings (255/608).
+        license_plate: Registration plate (410/608).
+        make: Manufacturer (576/608).
+        model: Vehicle model name (576/608).
+        vin: Vehicle identification number (576/608).
+        year: Model year; a quoted integer on the wire, typed by lax
+            coercion (576/608).
+        static_assigned_driver: Statically assigned driver reference
+            (198/608).
+        aux_input_type1: Auxiliary input assignment (12/608;
+            ``"powerTakeOff"`` captured), mirrored, never interpreted.
+    """
+
+    model_config = ConfigDict(alias_generator=to_camel)
+
+    # Identity and lifecycle.
+    id: str
+    name: str
+    notes: str
+    harsh_acceleration_setting_type: str
+    vehicle_regulation_mode: str
+    created_at_time: datetime
+    updated_at_time: datetime
+
+    # Installed hardware.
+    camera_serial: str | None = None
+    external_ids: VehicleExternalIds | None = None
+    gateway: VehicleGatewayRef | None = None
+    serial: str | None = None
+    esn: str | None = None
+
+    # Vehicle identity.
+    license_plate: str | None = None
+    make: str | None = None
+    model: str | None = None
+    vin: str | None = None
+    year: int | None = None
+
+    # Assignment.
+    static_assigned_driver: VehicleStaticAssignedDriverRef | None = None
+    aux_input_type1: str | None = None