Alexa typing part 2 (#97911)

* Alexa typing part 2

* Update homeassistant/components/alexa/intent.py

Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>

* Missed type hints

* precision

* Follow up comment

* value

* revert abstract class changes

* raise NotImplementedError()

---------

Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>

homeassistant/components/alexa/resources.py

@@ -1,6 +1,9 @@
 """Alexa Resources and Assets."""
 
 
+from typing import Any
+
+
 class AlexaGlobalCatalog:
     """The Global Alexa catalog.
 
@@ -207,36 +210,40 @@ class AlexaCapabilityResource:
     https://developer.amazon.com/docs/device-apis/resources-and-assets.html#capability-resources
     """
 
-    def __init__(self, labels):
+    def __init__(self, labels: list[str]) -> None:
         """Initialize an Alexa resource."""
         self._resource_labels = []
         for label in labels:
             self._resource_labels.append(label)
 
-    def serialize_capability_resources(self):
+    def serialize_capability_resources(self) -> dict[str, list[dict[str, Any]]]:
         """Return capabilityResources object serialized for an API response."""
         return self.serialize_labels(self._resource_labels)
 
-    def serialize_configuration(self):
+    def serialize_configuration(self) -> dict[str, Any]:
         """Return serialized configuration for an API response.
 
         Return ModeResources, PresetResources friendlyNames serialized.
         """
-        return []
+        raise NotImplementedError()
 
-    def serialize_labels(self, resources):
+    def serialize_labels(self, resources: list[str]) -> dict[str, list[dict[str, Any]]]:
         """Return serialized labels for an API response.
 
         Returns resource label objects for friendlyNames serialized.
         """
-        labels = []
+        labels: list[dict[str, Any]] = []
+        label_dict: dict[str, Any]
         for label in resources:
             if label in AlexaGlobalCatalog.__dict__.values():
-                label = {"@type": "asset", "value": {"assetId": label}}
+                label_dict = {"@type": "asset", "value": {"assetId": label}}
             else:
-                label = {"@type": "text", "value": {"text": label, "locale": "en-US"}}
+                label_dict = {
+                    "@type": "text",
+                    "value": {"text": label, "locale": "en-US"},
+                }
 
-            labels.append(label)
+            labels.append(label_dict)
 
         return {"friendlyNames": labels}
 
@@ -247,22 +254,22 @@ class AlexaModeResource(AlexaCapabilityResource):
     https://developer.amazon.com/docs/device-apis/resources-and-assets.html#capability-resources
     """
 
-    def __init__(self, labels, ordered=False):
+    def __init__(self, labels: list[str], ordered: bool = False) -> None:
         """Initialize an Alexa modeResource."""
         super().__init__(labels)
-        self._supported_modes = []
-        self._mode_ordered = ordered
+        self._supported_modes: list[dict[str, Any]] = []
+        self._mode_ordered: bool = ordered
 
-    def add_mode(self, value, labels):
+    def add_mode(self, value: str, labels: list[str]) -> None:
         """Add mode to the supportedModes object."""
         self._supported_modes.append({"value": value, "labels": labels})
 
-    def serialize_configuration(self):
+    def serialize_configuration(self) -> dict[str, Any]:
         """Return serialized configuration for an API response.
 
         Returns configuration for ModeResources friendlyNames serialized.
         """
-        mode_resources = []
+        mode_resources: list[dict[str, Any]] = []
         for mode in self._supported_modes:
             result = {
                 "value": mode["value"],
@@ -282,10 +289,17 @@ class AlexaPresetResource(AlexaCapabilityResource):
     https://developer.amazon.com/docs/device-apis/resources-and-assets.html#presetresources
     """
 
-    def __init__(self, labels, min_value, max_value, precision, unit=None):
+    def __init__(
+        self,
+        labels: list[str],
+        min_value: int | float,
+        max_value: int | float,
+        precision: int | float,
+        unit: str | None = None,
+    ) -> None:
         """Initialize an Alexa presetResource."""
         super().__init__(labels)
-        self._presets = []
+        self._presets: list[dict[str, Any]] = []
         self._minimum_value = min_value
         self._maximum_value = max_value
         self._precision = precision
@@ -293,16 +307,16 @@ class AlexaPresetResource(AlexaCapabilityResource):
         if unit in AlexaGlobalCatalog.__dict__.values():
             self._unit_of_measure = unit
 
-    def add_preset(self, value, labels):
+    def add_preset(self, value: int | float, labels: list[str]) -> None:
         """Add preset to configuration presets array."""
         self._presets.append({"value": value, "labels": labels})
 
-    def serialize_configuration(self):
+    def serialize_configuration(self) -> dict[str, Any]:
         """Return serialized configuration for an API response.
 
         Returns configuration for PresetResources friendlyNames serialized.
         """
-        configuration = {
+        configuration: dict[str, Any] = {
             "supportedRange": {
                 "minimumValue": self._minimum_value,
                 "maximumValue": self._maximum_value,
@@ -372,26 +386,28 @@ class AlexaSemantics:
     DIRECTIVE_MODE_SET_MODE = "SetMode"
     DIRECTIVE_MODE_ADJUST_MODE = "AdjustMode"
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize an Alexa modeResource."""
-        self._action_mappings = []
-        self._state_mappings = []
+        self._action_mappings: list[dict[str, Any]] = []
+        self._state_mappings: list[dict[str, Any]] = []
 
-    def _add_action_mapping(self, semantics):
+    def _add_action_mapping(self, semantics: dict[str, Any]) -> None:
         """Add action mapping between actions and interface directives."""
         self._action_mappings.append(semantics)
 
-    def _add_state_mapping(self, semantics):
+    def _add_state_mapping(self, semantics: dict[str, Any]) -> None:
         """Add state mapping between states and interface directives."""
         self._state_mappings.append(semantics)
 
-    def add_states_to_value(self, states, value):
+    def add_states_to_value(self, states: list[str], value: int | float) -> None:
         """Add StatesToValue stateMappings."""
         self._add_state_mapping(
             {"@type": self.STATES_TO_VALUE, "states": states, "value": value}
         )
 
-    def add_states_to_range(self, states, min_value, max_value):
+    def add_states_to_range(
+        self, states: list[str], min_value: int | float, max_value: int | float
+    ) -> None:
         """Add StatesToRange stateMappings."""
         self._add_state_mapping(
             {
@@ -401,7 +417,9 @@ class AlexaSemantics:
             }
         )
 
-    def add_action_to_directive(self, actions, directive, payload):
+    def add_action_to_directive(
+        self, actions: list[str], directive: str, payload: dict[str, Any]
+    ) -> None:
         """Add ActionsToDirective actionMappings."""
         self._add_action_mapping(
             {
@@ -411,9 +429,9 @@ class AlexaSemantics:
             }
         )
 
-    def serialize_semantics(self):
+    def serialize_semantics(self) -> dict[str, Any]:
         """Return semantics object serialized for an API response."""
-        semantics = {}
+        semantics: dict[str, Any] = {}
         if self._action_mappings:
             semantics[self.MAPPINGS_ACTION] = self._action_mappings
         if self._state_mappings: