Add comprehensive Tessie API endpoint coverage

This commit significantly expands the Tessie API implementation to include
all custom endpoints available in the Tessie API reference documentation.

Changes to tesla_fleet_api/tessie/tessie.py:
- Add historical data endpoints: states, drives, charges, idles, path
- Add location and mapping endpoints: location, map, weather
- Add battery and tire monitoring: consumption_since_charge, tire_pressure
- Add firmware and alert endpoints: firmware_alerts, vehicle_status
- Add fleet-wide endpoints: charging_invoices, all_battery_health
- Add license plate management: plate, update_plate

Changes to tesla_fleet_api/tessie/vehicles.py:
- Add complete set of vehicle command endpoints with wait_for_completion support
- Add climate control commands: start/stop climate, temperature, seat heat/cool
- Add trunk and window commands: activate trunks, vent/close windows
- Add charging commands: start/stop charging, set limits and amps
- Add security commands: lock/unlock, sentry mode, valet mode, guest mode
- Add software update commands: schedule and cancel updates
- Add scheduling commands: scheduled charging and departure
- Add driver management endpoints: list, delete, invite drivers
- Add fleet telemetry configuration endpoints
- Add data management: set drive tags and charge costs
- Prefix conflicting method names with 'tessie_' to avoid parent class conflicts

All changes pass pyright type checking and ruff linting.

Author: claude

tesla_fleet_api/tessie/tessie.py

@@ -83,3 +83,182 @@ async def all_battery_health(
                 "only_active": only_active,
             },
         )
+
+    async def states(
+        self,
+        vin: str,
+        start: int | None = None,
+        end: int | None = None,
+        results: int | None = None,
+        page: int | None = None,
+        exclude: str | None = None,
+        fields: str | None = None,
+    ) -> Any:
+        """Get historical vehicle states within timeframe."""
+        return await self._request(
+            Method.GET,
+            f"{vin}/states",
+            params={
+                "from": start,
+                "to": end,
+                "results": results,
+                "page": page,
+                "exclude": exclude,
+                "fields": fields,
+            },
+        )
+
+    async def location(self, vin: str) -> Any:
+        """Get coordinates, address, and saved location."""
+        return await self._request(Method.GET, f"{vin}/location")
+
+    async def firmware_alerts(self, vin: str) -> Any:
+        """Get list of firmware-generated alerts."""
+        return await self._request(Method.GET, f"{vin}/firmware_alerts")
+
+    async def map(
+        self,
+        vin: str,
+        width: int | None = None,
+        height: int | None = None,
+        zoom: int | None = None,
+    ) -> Any:
+        """Get map image of vehicle location."""
+        return await self._request(
+            Method.GET,
+            f"{vin}/map",
+            params={"width": width, "height": height, "zoom": zoom},
+        )
+
+    async def consumption_since_charge(self, vin: str) -> Any:
+        """Get energy use data since last charge."""
+        return await self._request(Method.GET, f"{vin}/consumption_since_charge")
+
+    async def weather(self, vin: str) -> Any:
+        """Get weather forecast around vehicle."""
+        return await self._request(Method.GET, f"{vin}/weather")
+
+    async def drives(
+        self,
+        vin: str,
+        start: int | None = None,
+        end: int | None = None,
+        results: int | None = None,
+        page: int | None = None,
+        timezone: str | None = None,
+        distance_format: str | None = None,
+    ) -> Any:
+        """Get historical drive records."""
+        return await self._request(
+            Method.GET,
+            f"{vin}/drives",
+            params={
+                "from": start,
+                "to": end,
+                "results": results,
+                "page": page,
+                "timezone": timezone,
+                "distance_format": distance_format,
+            },
+        )
+
+    async def path(
+        self,
+        vin: str,
+        start: int,
+        end: int,
+        timezone: str | None = None,
+    ) -> Any:
+        """Get driving route during specified timeframe."""
+        return await self._request(
+            Method.GET,
+            f"{vin}/path",
+            params={"from": start, "to": end, "timezone": timezone},
+        )
+
+    async def charges(
+        self,
+        vin: str,
+        start: int | None = None,
+        end: int | None = None,
+        results: int | None = None,
+        page: int | None = None,
+        timezone: str | None = None,
+        distance_format: str | None = None,
+    ) -> Any:
+        """Get charging history."""
+        return await self._request(
+            Method.GET,
+            f"{vin}/charges",
+            params={
+                "from": start,
+                "to": end,
+                "results": results,
+                "page": page,
+                "timezone": timezone,
+                "distance_format": distance_format,
+            },
+        )
+
+    async def charging_invoices(
+        self,
+        start: int | None = None,
+        end: int | None = None,
+        only_active: bool = False,
+    ) -> Any:
+        """Get charging costs for all vehicles (fleet)."""
+        return await self._request(
+            Method.GET,
+            "charging_invoices",
+            params={"from": start, "to": end, "only_active": only_active},
+        )
+
+    async def idles(
+        self,
+        vin: str,
+        start: int | None = None,
+        end: int | None = None,
+        results: int | None = None,
+        page: int | None = None,
+        timezone: str | None = None,
+    ) -> Any:
+        """Get idle periods when vehicle inactive."""
+        return await self._request(
+            Method.GET,
+            f"{vin}/idles",
+            params={
+                "from": start,
+                "to": end,
+                "results": results,
+                "page": page,
+                "timezone": timezone,
+            },
+        )
+
+    async def last_idle_state(self, vin: str) -> Any:
+        """Get latest idle period data."""
+        return await self._request(Method.GET, f"{vin}/last_idle_state")
+
+    async def tire_pressure(self, vin: str) -> Any:
+        """Get current tire pressure readings."""
+        return await self._request(Method.GET, f"{vin}/tire_pressure")
+
+    async def vehicle_status(self, vin: str) -> Any:
+        """Get vehicle operational status."""
+        return await self._request(Method.GET, f"{vin}/status")
+
+    async def plate(self, vin: str) -> Any:
+        """Get license plate information."""
+        return await self._request(Method.GET, f"{vin}/plate")
+
+    async def update_plate(
+        self,
+        vin: str,
+        plate: str,
+        state: str | None = None,
+    ) -> Any:
+        """Update license plate information."""
+        params: dict[str, str] = {"plate": plate}
+        if state:
+            params["state"] = state
+        return await self._request(Method.POST, f"{vin}/plate", params=params)