axis 71__tar.gz → 72__tar.gz

{axis-71 → axis-72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axis
-Version: 71
+Version: 72
 Summary: A Python library for communicating with devices from Axis Communications
 Author-email: Robert Svensson <Kane610@users.noreply.github.com>
 License: MIT
@@ -28,13 +28,13 @@ Requires-Dist: orjson==3.11.9; extra == "requirements"
 Requires-Dist: packaging==26.2; extra == "requirements"
 Requires-Dist: xmltodict==1.0.4; extra == "requirements"
 Provides-Extra: requirements-test
-Requires-Dist: mypy==2.0.0; extra == "requirements-test"
+Requires-Dist: mypy==2.1.0; extra == "requirements-test"
 Requires-Dist: pytest==9.0.3; extra == "requirements-test"
 Requires-Dist: pytest-aiohttp==1.1.0; extra == "requirements-test"
 Requires-Dist: pytest-asyncio==1.3.0; extra == "requirements-test"
 Requires-Dist: pytest-cov==7.1.0; extra == "requirements-test"
-Requires-Dist: ruff==0.15.12; extra == "requirements-test"
-Requires-Dist: types-xmltodict==v1.0.1.20260508; extra == "requirements-test"
+Requires-Dist: ruff==0.15.13; extra == "requirements-test"
+Requires-Dist: types-xmltodict==v1.0.1.20260518; extra == "requirements-test"
 Provides-Extra: requirements-dev
 Requires-Dist: pre-commit==4.6.0; extra == "requirements-dev"
 Dynamic: license-file
@@ -89,7 +89,42 @@ Vapix initialization is phase-based and driven by handler metadata:
 
 Handlers declare phase membership through `handler_groups` and may customize phase eligibility through `should_initialize_in_group`.
 
+## Request and response typing
+
+`Vapix.api_request()` is the single typed request entrypoint.
+
+- Request models declare their decode contract with `ApiRequest[ResponseT]`.
+- Every `ApiRequest` subclass must set `response_type` explicitly.
+- Decoded/read requests use their concrete response model as `response_type`.
+- Write-style requests use `BytesResponse` as `response_type`.
+
+Examples:
+
+```python
+@dataclass
+class ListApisRequest(ApiRequest[GetAllApisResponse]):
+	response_type = GetAllApisResponse
+
+
+@dataclass
+class SetPortsRequest(ApiRequest[ApiResponse[bytes]]):
+	response_type = BytesResponse
+```
+
+Handler methods may unwrap `.data` when they intentionally preserve a bytes-returning boundary.
+
 Example fallback policy:
 
 - `LightHandler` participates in both `API_DISCOVERY` and `PARAM_CGI_FALLBACK`.
 - In `PARAM_CGI_FALLBACK`, it initializes only when not listed in API discovery and listed in parameters.
+
+## Event Instance Model Notes
+
+`EventInstance` keeps `name` as the raw device-provided `NiceName` value.
+
+`EventInstance.source` and `EventInstance.data` are typed containers (`EventInstanceSource` and `EventInstanceData`) built from `SimpleItemInstance` payloads.
+
+For compatibility with integrations that still need the historical raw payload shape, `EventInstance` also exposes:
+
+- `raw_source`: returns `{}` or a dict or a list of dicts.
+- `raw_data`: returns `{}` or a dict or a list of dicts.

{axis-71 → axis-72}/README.md

@@ -48,7 +48,42 @@ Vapix initialization is phase-based and driven by handler metadata:
 
 Handlers declare phase membership through `handler_groups` and may customize phase eligibility through `should_initialize_in_group`.
 
+## Request and response typing
+
+`Vapix.api_request()` is the single typed request entrypoint.
+
+- Request models declare their decode contract with `ApiRequest[ResponseT]`.
+- Every `ApiRequest` subclass must set `response_type` explicitly.
+- Decoded/read requests use their concrete response model as `response_type`.
+- Write-style requests use `BytesResponse` as `response_type`.
+
+Examples:
+
+```python
+@dataclass
+class ListApisRequest(ApiRequest[GetAllApisResponse]):
+	response_type = GetAllApisResponse
+
+
+@dataclass
+class SetPortsRequest(ApiRequest[ApiResponse[bytes]]):
+	response_type = BytesResponse
+```
+
+Handler methods may unwrap `.data` when they intentionally preserve a bytes-returning boundary.
+
 Example fallback policy:
 
 - `LightHandler` participates in both `API_DISCOVERY` and `PARAM_CGI_FALLBACK`.
 - In `PARAM_CGI_FALLBACK`, it initializes only when not listed in API discovery and listed in parameters.
+
+## Event Instance Model Notes
+
+`EventInstance` keeps `name` as the raw device-provided `NiceName` value.
+
+`EventInstance.source` and `EventInstance.data` are typed containers (`EventInstanceSource` and `EventInstanceData`) built from `SimpleItemInstance` payloads.
+
+For compatibility with integrations that still need the historical raw payload shape, `EventInstance` also exposes:
+
+- `raw_source`: returns `{}` or a dict or a list of dicts.
+- `raw_data`: returns `{}` or a dict or a list of dicts.

{axis-71 → axis-72}/axis/__main__.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 LOGGER = logging.getLogger(__name__)
 
 
-def event_handler(event: "Event") -> None:
+def event_handler(event: Event) -> None:
     """Receive and print events from RTSP stream."""
     LOGGER.info(event)
 
@@ -61,8 +61,8 @@ async def axis_device(
             "Connected to device at %s but not registered or user not admin.", host
         )
 
-    except (TimeoutError, axis.RequestError):
-        LOGGER.error("Error connecting to the Axis device at %s", host)
+    except (TimeoutError, axis.RequestError) as err:
+        LOGGER.error("Error connecting to the Axis device at %s: %s", host, err)
 
     except axis.AxisException:
         LOGGER.exception("Unknown Axis communication error occurred")

{axis-71 → axis-72}/axis/interfaces/aiohttp_digest.py

@@ -4,8 +4,6 @@ Implements library-managed RFC 2617 digest authentication for aiohttp requests
 to handle special characters in request parameters that break middleware-based auth.
 """
 
-from __future__ import annotations
-
 import hashlib
 import logging
 import re

{axis-71 → axis-72}/axis/interfaces/api_discovery.py

@@ -8,9 +8,7 @@ from ..models.api_discovery import (
     API_VERSION,
     Api,
     ApiId,
-    GetAllApisResponse,
     GetSupportedVersionsRequest,
-    GetSupportedVersionsResponse,
     ListApisRequest,
 )
 from .api_handler import ApiHandler
@@ -33,11 +31,10 @@ class ApiDiscoveryHandler(ApiHandler[Api]):
 
     async def get_api_list(self) -> dict[str, Api]:
         """List all APIs registered on API Discovery service."""
-        bytes_data = await self.vapix.api_request(ListApisRequest())
-        return GetAllApisResponse.decode(bytes_data).data
+        response = await self.vapix.api_request(ListApisRequest())
+        return response.data
 
     async def get_supported_versions(self) -> list[str]:
         """List supported API versions."""
-        bytes_data = await self.vapix.api_request(GetSupportedVersionsRequest())
-        response = GetSupportedVersionsResponse.decode(bytes_data)
+        response = await self.vapix.api_request(GetSupportedVersionsRequest())
         return response.data

{axis-71 → axis-72}/axis/interfaces/api_handler.py

@@ -9,7 +9,7 @@ from collections.abc import (
     ValuesView,
 )
 import enum
-from typing import TYPE_CHECKING, Generic, final
+from typing import TYPE_CHECKING, final
 
 from ..errors import Forbidden, PathNotFound, Unauthorized
 
@@ -17,11 +17,11 @@ if TYPE_CHECKING:
     from ..models.api_discovery import ApiId
     from .vapix import Vapix
 
-from ..models.api import ApiItemT
+from ..models.api import ApiItem
 
-CallbackType = Callable[[str], None]
-SubscriptionType = CallbackType
-UnsubscribeType = Callable[[], None]
+type CallbackType = Callable[[str], None]
+type SubscriptionType = CallbackType
+type UnsubscribeType = Callable[[], None]
 
 ID_FILTER_ALL = "*"
 
@@ -62,6 +62,8 @@ class SubscriptionHandler:
             _id_filter = (ID_FILTER_ALL,)
         elif isinstance(id_filter, str):
             _id_filter = (id_filter,)
+        else:
+            _id_filter = id_filter
 
         for obj_id in _id_filter:
             if obj_id not in self._subscribers:
@@ -79,7 +81,7 @@ class SubscriptionHandler:
         return unsubscribe
 
 
-class ApiHandler(SubscriptionHandler, Generic[ApiItemT]):
+class ApiHandler[ApiItemT: ApiItem](SubscriptionHandler):
     """Base class for a map of API Items."""
 
     api_id: ApiId | None = None

{axis-71 → axis-72}/axis/interfaces/applications/application_handler.py

@@ -2,12 +2,12 @@
 
 from abc import abstractmethod
 
-from ...models.api import ApiItemT
+from ...models.api import ApiItem
 from ...models.applications.application import ApplicationName, ApplicationStatus
 from ..api_handler import ApiHandler, HandlerGroup
 
 
-class ApplicationHandler(ApiHandler[ApiItemT]):
+class ApplicationHandler[ApiItemT: ApiItem](ApiHandler[ApiItemT]):
     """Generic application handler."""
 
     app_name: ApplicationName

{axis-71 → axis-72}/axis/interfaces/applications/applications.py

@@ -9,7 +9,6 @@ from packaging import version
 from ...models.applications.application import (
     Application,
     ListApplicationsRequest,
-    ListApplicationsResponse,
 )
 from ..api_handler import ApiHandler
 
@@ -36,6 +35,5 @@ class ApplicationsHandler(ApiHandler[Application]):
 
     async def list_applications(self) -> dict[str, Application]:
         """List all APIs registered on API Discovery service."""
-        bytes_data = await self.vapix.api_request(ListApplicationsRequest())
-        response = ListApplicationsResponse.decode(bytes_data)
+        response = await self.vapix.api_request(ListApplicationsRequest())
         return response.data

{axis-71 → axis-72}/axis/interfaces/applications/fence_guard.py

@@ -10,7 +10,6 @@ from ...models.applications.application import ApplicationName
 from ...models.applications.fence_guard import (
     Configuration,
     GetConfigurationRequest,
-    GetConfigurationResponse,
 )
 from .application_handler import ApplicationHandler
 
@@ -22,6 +21,5 @@ class FenceGuardHandler(ApplicationHandler[Configuration]):
 
     async def get_configuration(self) -> Configuration:
         """Get configuration of VMD4 application."""
-        bytes_data = await self.vapix.api_request(GetConfigurationRequest())
-        response = GetConfigurationResponse.decode(bytes_data)
+        response = await self.vapix.api_request(GetConfigurationRequest())
         return response.data

{axis-71 → axis-72}/axis/interfaces/applications/loitering_guard.py

@@ -8,7 +8,6 @@ from ...models.applications.application import ApplicationName
 from ...models.applications.loitering_guard import (
     Configuration,
     GetConfigurationRequest,
-    GetConfigurationResponse,
 )
 from .application_handler import ApplicationHandler
 
@@ -20,6 +19,5 @@ class LoiteringGuardHandler(ApplicationHandler[Configuration]):
 
     async def get_configuration(self) -> Configuration:
         """Get configuration of VMD4 application."""
-        bytes_data = await self.vapix.api_request(GetConfigurationRequest())
-        response = GetConfigurationResponse.decode(bytes_data)
+        response = await self.vapix.api_request(GetConfigurationRequest())
         return response.data

{axis-71 → axis-72}/axis/interfaces/applications/motion_guard.py

@@ -9,7 +9,6 @@ from ...models.applications.application import ApplicationName
 from ...models.applications.motion_guard import (
     Configuration,
     GetConfigurationRequest,
-    GetConfigurationResponse,
 )
 from .application_handler import ApplicationHandler
 
@@ -21,6 +20,5 @@ class MotionGuardHandler(ApplicationHandler[Configuration]):
 
     async def get_configuration(self) -> Configuration:
         """Get configuration of VMD4 application."""
-        bytes_data = await self.vapix.api_request(GetConfigurationRequest())
-        response = GetConfigurationResponse.decode(bytes_data)
+        response = await self.vapix.api_request(GetConfigurationRequest())
         return response.data

{axis-71 → axis-72}/axis/interfaces/applications/object_analytics.py

@@ -7,7 +7,6 @@ from ...models.applications.application import ApplicationName
 from ...models.applications.object_analytics import (
     Configuration,
     GetConfigurationRequest,
-    GetConfigurationResponse,
 )
 from .application_handler import ApplicationHandler
 
@@ -19,6 +18,5 @@ class ObjectAnalyticsHandler(ApplicationHandler[Configuration]):
 
     async def get_configuration(self) -> Configuration:
         """Get configuration of object analytics application."""
-        bytes_data = await self.vapix.api_request(GetConfigurationRequest())
-        response = GetConfigurationResponse.decode(bytes_data)
+        response = await self.vapix.api_request(GetConfigurationRequest())
         return response.data

{axis-71 → axis-72}/axis/interfaces/applications/vmd4.py

@@ -4,7 +4,6 @@ from ...models.applications.application import ApplicationName
 from ...models.applications.vmd4 import (
     Configuration,
     GetConfigurationRequest,
-    GetConfigurationResponse,
 )
 from .application_handler import ApplicationHandler
 
@@ -16,6 +15,5 @@ class Vmd4Handler(ApplicationHandler[Configuration]):
 
     async def get_configuration(self) -> Configuration:
         """Get configuration of VMD4 application."""
-        bytes_data = await self.vapix.api_request(GetConfigurationRequest())
-        response = GetConfigurationResponse.decode(bytes_data)
+        response = await self.vapix.api_request(GetConfigurationRequest())
         return response.data

{axis-71 → axis-72}/axis/interfaces/basic_device_info.py

@@ -10,9 +10,7 @@ from ..models.basic_device_info import (
     API_VERSION,
     DeviceInformation,
     GetAllPropertiesRequest,
-    GetAllPropertiesResponse,
     GetSupportedVersionsRequest,
-    GetSupportedVersionsResponse,
 )
 from .api_handler import ApiHandler, HandlerGroup
 
@@ -30,14 +28,12 @@ class BasicDeviceInfoHandler(ApiHandler[DeviceInformation]):
 
     async def get_all_properties(self) -> dict[str, DeviceInformation]:
         """List all properties of basic device info."""
-        bytes_data = await self.vapix.api_request(
+        response = await self.vapix.api_request(
             GetAllPropertiesRequest(self.api_version)
         )
-        response = GetAllPropertiesResponse.decode(bytes_data)
         return {"0": response.data}
 
     async def get_supported_versions(self) -> list[str]:
         """List supported API versions."""
-        bytes_data = await self.vapix.api_request(GetSupportedVersionsRequest())
-        response = GetSupportedVersionsResponse.decode(bytes_data)
+        response = await self.vapix.api_request(GetSupportedVersionsRequest())
         return response.data

axis-72/axis/interfaces/event_instances.py

@@ -0,0 +1,43 @@
+"""Event service and action service APIs available in Axis network device."""
+
+from typing import TYPE_CHECKING
+
+from ..models.event_instance import (
+    EventInstance,
+    ListEventInstancesRequest,
+)
+from .api_handler import ApiHandler
+from .event_manager import BLACK_LISTED_TOPICS
+
+if TYPE_CHECKING:
+    from ..models.event import Event
+
+
+class EventInstanceHandler(ApiHandler[EventInstance]):
+    """Event instances for Axis devices."""
+
+    async def _api_request(self) -> dict[str, EventInstance]:
+        """Get default data of API discovery."""
+        return await self.get_event_instances()
+
+    async def get_event_instances(self) -> dict[str, EventInstance]:
+        """List all event instances."""
+        response = await self.vapix.api_request(ListEventInstancesRequest())
+        return response.data
+
+    def get_expected_events_per_topic(
+        self,
+        include_internal_topics: bool = False,
+    ) -> dict[str, list[Event]]:
+        """Return expected startup events grouped by topic.
+
+        Event instances are the protocol-agnostic bootstrap source for startup
+        predeclaration. Returned events are synthesized from schema data and represent
+        expected event identity/state (operation=Initialized), not live stream updates.
+        """
+        grouped: dict[str, list[Event]] = {}
+        for item in self.values():
+            if not include_internal_topics and item.topic in BLACK_LISTED_TOPICS:
+                continue
+            grouped[item.topic] = item.to_events()
+        return grouped

{axis-71 → axis-72}/axis/interfaces/event_manager.py

@@ -6,17 +6,19 @@ from typing import Any
 
 from ..models.event import Event, EventOperation, EventTopic
 
-SubscriptionCallback = Callable[[Event], None]
-SubscriptionType = tuple[
+type SubscriptionCallback = Callable[[Event], None]
+type SubscriptionType = tuple[
     SubscriptionCallback,
     tuple[EventTopic, ...] | None,
     tuple[EventOperation, ...] | None,
 ]
-UnsubscribeType = Callable[[], None]
+type UnsubscribeType = Callable[[], None]
 
 ID_FILTER_ALL = "*"
 
 BLACK_LISTED_TOPICS = [
+    "tns1:RuleEngine/tnsaxis:VideoMotionDetection/timer",
+    "tns1:RuleEngine/tnsaxis:VMD3/timer",
     "tnsaxis:CameraApplicationPlatform/VMD/xinternal_data",
     "tnsaxis:CameraApplicationPlatform/ObjectAnalytics/xinternal_data",
 ]
@@ -29,6 +31,7 @@ class EventManager:
     def __init__(self) -> None:
         """Ready information about events."""
         self._known_topics: set[str] = set()
+        self._unsupported_topics: set[str] = set()
         self._subscribers: dict[str, list[SubscriptionType]] = {ID_FILTER_ALL: []}
 
     def handler(self, data: bytes | dict[str, Any]) -> None:
@@ -37,7 +40,13 @@ class EventManager:
         if LOGGER.isEnabledFor(logging.DEBUG):
             LOGGER.debug(event)
 
-        if event.topic_base == EventTopic.UNKNOWN or event.topic in BLACK_LISTED_TOPICS:
+        if event.topic_base == EventTopic.UNKNOWN:
+            if event.topic not in self._unsupported_topics:
+                LOGGER.warning("Ignoring unsupported event topic %s", event.topic)
+                self._unsupported_topics.add(event.topic)
+            return
+
+        if event.topic in BLACK_LISTED_TOPICS:
             return
 
         known = (unique_topic := f"{event.topic}_{event.id}") not in self._known_topics

{axis-71 → axis-72}/axis/interfaces/light_control.py

@@ -12,29 +12,18 @@ from ..models.light_control import (
     DisableLightRequest,
     EnableLightRequest,
     GetCurrentAngleOfIlluminationRequest,
-    GetCurrentAngleOfIlluminationResponse,
     GetCurrentIntensityRequest,
-    GetCurrentIntensityResponse,
     GetIndividualIntensityRequest,
-    GetIndividualIntensityResponse,
     GetLightInformationRequest,
-    GetLightInformationResponse,
     GetLightStatusRequest,
-    GetLightStatusResponse,
     GetLightSynchronizeDayNightModeRequest,
     GetLightSynchronizeDayNightModeResponse,
     GetManualAngleOfIlluminationRequest,
-    GetManualAngleOfIlluminationResponse,
     GetManualIntensityRequest,
-    GetManualIntensityResponse,
     GetServiceCapabilitiesRequest,
-    GetServiceCapabilitiesResponse,
     GetSupportedVersionsRequest,
-    GetSupportedVersionsResponse,
     GetValidAngleOfIlluminationRequest,
-    GetValidAngleOfIlluminationResponse,
     GetValidIntensityRequest,
-    GetValidIntensityResponse,
     LightInformation,
     Range,
     ServiceCapabilities,
@@ -77,17 +66,17 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_light_information(self) -> dict[str, LightInformation]:
         """List the light control information."""
-        bytes_data = await self.vapix.api_request(
+        response = await self.vapix.api_request(
             GetLightInformationRequest(api_version=self.api_version)
         )
-        return GetLightInformationResponse.decode(bytes_data).data
+        return response.data
 
     async def get_service_capabilities(self) -> ServiceCapabilities:
         """List the light control information."""
-        bytes_data = await self.vapix.api_request(
+        response = await self.vapix.api_request(
             GetServiceCapabilitiesRequest(api_version=self.api_version)
         )
-        return GetServiceCapabilitiesResponse.decode(bytes_data).data
+        return response.data
 
     async def activate_light(self, light_id: str) -> None:
         """Activate the light."""
@@ -115,10 +104,10 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_light_status(self, light_id: str) -> bool:
         """Get light status if its on or off."""
-        bytes_data = await self.vapix.api_request(
+        response = await self.vapix.api_request(
             GetLightStatusRequest(api_version=self.api_version, light_id=light_id)
         )
-        return GetLightStatusResponse.decode(bytes_data).data
+        return response.data
 
     async def set_automatic_intensity_mode(self, light_id: str, enabled: bool) -> None:
         """Enable the automatic light intensity control."""
@@ -132,10 +121,10 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_valid_intensity(self, light_id: str) -> Range:
         """Get valid intensity range for light."""
-        bytes_data = await self.vapix.api_request(
+        response = await self.vapix.api_request(
             GetValidIntensityRequest(api_version=self.api_version, light_id=light_id)
         )
-        return GetValidIntensityResponse.decode(bytes_data).data
+        return response.data
 
     async def set_manual_intensity(self, light_id: str, intensity: int) -> None:
         """Manually sets the intensity."""
@@ -149,10 +138,10 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_manual_intensity(self, light_id: str) -> int:
         """Enable the automatic light intensity control."""
-        bytes_data = await self.vapix.api_request(
+        response = await self.vapix.api_request(
             GetManualIntensityRequest(api_version=self.api_version, light_id=light_id)
         )
-        return GetManualIntensityResponse.decode(bytes_data).data
+        return response.data
 
     async def set_individual_intensity(
         self, light_id: str, led_id: int, intensity: int
@@ -169,21 +158,21 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_individual_intensity(self, light_id: str, led_id: int) -> int:
         """Receives the intensity from the setIndividualIntensity request."""
-        bytes_data = await self.vapix.api_request(
+        response = await self.vapix.api_request(
             GetIndividualIntensityRequest(
                 api_version=self.api_version,
                 light_id=light_id,
                 led_id=led_id,
             )
         )
-        return GetIndividualIntensityResponse.decode(bytes_data).data
+        return response.data
 
     async def get_current_intensity(self, light_id: str) -> int:
         """Receives the intensity from the setIndividualIntensity request."""
-        bytes_data = await self.vapix.api_request(
+        response = await self.vapix.api_request(
             GetCurrentIntensityRequest(api_version=self.api_version, light_id=light_id)
         )
-        return GetCurrentIntensityResponse.decode(bytes_data).data
+        return response.data
 
     async def set_automatic_angle_of_illumination_mode(
         self, light_id: str, enabled: bool
@@ -203,12 +192,12 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_valid_angle_of_illumination(self, light_id: str) -> list[Range]:
         """List the valid angle of illumination values."""
-        bytes_data = await self.vapix.api_request(
+        response = await self.vapix.api_request(
             GetValidAngleOfIlluminationRequest(
                 api_version=self.api_version, light_id=light_id
             )
         )
-        return GetValidAngleOfIlluminationResponse.decode(bytes_data).data
+        return response.data
 
     async def set_manual_angle_of_illumination(
         self, light_id: str, angle_of_illumination: int
@@ -228,21 +217,21 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_manual_angle_of_illumination(self, light_id: str) -> int:
         """Get the angle of illumination."""
-        bytes_data = await self.vapix.api_request(
+        response = await self.vapix.api_request(
             GetManualAngleOfIlluminationRequest(
                 api_version=self.api_version, light_id=light_id
             )
         )
-        return GetManualAngleOfIlluminationResponse.decode(bytes_data).data
+        return response.data
 
     async def get_current_angle_of_illumination(self, light_id: str) -> int:
         """Receive the current angle of illumination."""
-        bytes_data = await self.vapix.api_request(
+        response = await self.vapix.api_request(
             GetCurrentAngleOfIlluminationRequest(
                 api_version=self.api_version, light_id=light_id
             )
         )
-        return GetCurrentAngleOfIlluminationResponse.decode(bytes_data).data
+        return response.data
 
     async def set_light_synchronization_day_night_mode(
         self, light_id: str, enabled: bool
@@ -258,14 +247,16 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_light_synchronization_day_night_mode(self, light_id: str) -> bool:
         """Check if the automatic synchronization is enabled with the day/night mode."""
-        bytes_data = await self.vapix.api_request(
-            GetLightSynchronizeDayNightModeRequest(
-                api_version=self.api_version, light_id=light_id
+        response: GetLightSynchronizeDayNightModeResponse = (
+            await self.vapix.api_request(
+                GetLightSynchronizeDayNightModeRequest(
+                    api_version=self.api_version, light_id=light_id
+                )
             )
         )
-        return GetLightSynchronizeDayNightModeResponse.decode(bytes_data).data
+        return response.data
 
     async def get_supported_versions(self) -> list[str]:
         """List supported API versions."""
-        bytes_data = await self.vapix.api_request(GetSupportedVersionsRequest())
-        return GetSupportedVersionsResponse.decode(bytes_data).data
+        response = await self.vapix.api_request(GetSupportedVersionsRequest())
+        return response.data