@@ -1,4 +1,14 @@
 from collections.abc import Callable
-from typing import Any, TypeVar
+from typing import Any, Protocol, TypeVar
 
 AnyCallableT = TypeVar("AnyCallableT", bound=Callable[..., Any])
+
+EventT_contra = TypeVar("EventT_contra", contravariant=True)
+ContextT_contra = TypeVar("ContextT_contra", contravariant=True)
+ReturnT_co = TypeVar("ReturnT_co", covariant=True)
+
+
+class LambdaHandler(Protocol[EventT_contra, ContextT_contra, ReturnT_co]):
+    """Lambda handler, callable with `event` and `context` as positional or keyword arguments."""
+
+    def __call__(self, event: EventT_contra, context: ContextT_contra) -> ReturnT_co: ...
@@ -7,6 +7,7 @@
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+    from aws_lambda_powertools.shared.types import LambdaHandler
     from aws_lambda_powertools.utilities.data_classes.common import DictWrapper
     from aws_lambda_powertools.utilities.typing import LambdaContext
 
@@ -15,15 +16,15 @@
 
 
 class _EventSourceDecorator(Protocol):
-    """Annotation of event_source, that lambda_handler_decorator erases at runtime."""
+    """Type of `event_source`, as `lambda_handler_decorator` returns an untyped `Callable`."""
 
     def __call__(
         self,
         *,
         data_class: type[DataClassT],
     ) -> Callable[
         [Callable[[DataClassT, LambdaContext], OutputT]],
-        Callable[[dict[str, Any], LambdaContext], OutputT],
+        LambdaHandler[dict[str, Any], LambdaContext, OutputT],
     ]: ...
 
 
 
@@ -9,7 +9,7 @@
 import os
 import warnings
 from inspect import isclass
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any, Protocol, TypeVar, cast
 
 from aws_lambda_powertools.middleware_factory import lambda_handler_decorator
 from aws_lambda_powertools.shared import constants
@@ -25,6 +25,7 @@
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+    from aws_lambda_powertools.shared.types import LambdaHandler
     from aws_lambda_powertools.utilities.idempotency.persistence.base import (
         BasePersistenceLayer,
     )
@@ -34,9 +35,33 @@
 
 logger = logging.getLogger(__name__)
 
+EventT = TypeVar("EventT")
+ContextT = TypeVar("ContextT", bound="LambdaContext | DurableContextProtocol")
+
+
+class _IdempotentHandlerDecorator(Protocol):
+    # The return type is Any, as responses replayed from the persistence store are deserialized JSON
+    def __call__(
+        self,
+        handler: Callable[[EventT, ContextT], Any],
+        /,
+    ) -> LambdaHandler[EventT, ContextT, Any]: ...
+
+
+class _IdempotentDecorator(Protocol):
+    """Type of `idempotent`, as `lambda_handler_decorator` returns an untyped `Callable`."""
+
+    def __call__(
+        self,
+        *,
+        persistence_store: BasePersistenceLayer,
+        config: IdempotencyConfig | None = None,
+        key_prefix: str | None = None,
+    ) -> _IdempotentHandlerDecorator: ...
+
 
 @lambda_handler_decorator
-def idempotent(
+def _idempotent(
     handler: Callable[[Any, LambdaContext | DurableContextProtocol], Any],
     event: dict[str, Any],
     context: LambdaContext | DurableContextProtocol,
@@ -117,6 +142,9 @@ def handler(event, context):
     return idempotency_handler.handle(is_replay=is_replay)
 
 
+idempotent = cast(_IdempotentDecorator, _idempotent)
+
+
 def idempotent_function(
     function: AnyCallableT | None = None,
     *,
 
@@ -1,16 +1,41 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Protocol, TypeVar, overload
 
 from aws_lambda_powertools.middleware_factory import lambda_handler_decorator
 from aws_lambda_powertools.utilities.kafka.consumer_records import ConsumerRecords
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+    from aws_lambda_powertools.shared.types import LambdaHandler
     from aws_lambda_powertools.utilities.kafka.schema_config import SchemaConfig
     from aws_lambda_powertools.utilities.typing import LambdaContext
 
+ReturnT = TypeVar("ReturnT")
+
+
+class _KafkaConsumerHandlerDecorator(Protocol):
+    def __call__(
+        self,
+        handler: Callable[[ConsumerRecords, LambdaContext], ReturnT],
+        /,
+    ) -> LambdaHandler[dict[str, Any], LambdaContext, ReturnT]: ...
+
+
+@overload
+def kafka_consumer(
+    handler: Callable[[ConsumerRecords, LambdaContext], ReturnT],
+    /,
+) -> LambdaHandler[dict[str, Any], LambdaContext, ReturnT]: ...
+
+
+@overload
+def kafka_consumer(
+    *,
+    schema_config: SchemaConfig | None = None,
+) -> _KafkaConsumerHandlerDecorator: ...
+
 
 @lambda_handler_decorator
 def kafka_consumer(
 
@@ -9,7 +9,7 @@
 
 import logging
 import typing
-from typing import TYPE_CHECKING, Any, Callable, overload
+from typing import TYPE_CHECKING, Any, Callable, Protocol, TypeVar, overload
 
 from pydantic import PydanticSchemaGenerationError
 
@@ -21,12 +21,62 @@
 )
 
 if TYPE_CHECKING:
-    from aws_lambda_powertools.utilities.parser.envelopes.base import Envelope
+    from pydantic import TypeAdapter
+
+    from aws_lambda_powertools.shared.types import LambdaHandler
+    from aws_lambda_powertools.utilities.parser.envelopes.base import BaseEnvelope, Envelope
     from aws_lambda_powertools.utilities.parser.types import EventParserReturnType, T
     from aws_lambda_powertools.utilities.typing import LambdaContext
 
 logger = logging.getLogger(__name__)
 
+ModelT_co = TypeVar("ModelT_co", covariant=True)
+ModelT = TypeVar("ModelT")
+ReturnT = TypeVar("ReturnT")
+
+
+class _EventParserModelHandlerDecorator(Protocol[ModelT_co]):
+    def __call__(
+        self,
+        handler: Callable[[ModelT_co, LambdaContext], ReturnT],
+        /,
+    ) -> LambdaHandler[dict[str, Any] | str, LambdaContext, ReturnT]: ...
+
+
+class _EventParserHandlerDecorator(Protocol):
+    # The handler's event type is Any, as it can't be derived from the arguments, e.g.
+    # - @event_parser()
+    # - @event_parser(model=Annotated[A | B, Field(discriminator="kind")])
+    # - @event_parser(model=A, envelope=SqsEnvelope)
+    def __call__(
+        self,
+        handler: Callable[[Any, LambdaContext], ReturnT],
+        /,
+    ) -> LambdaHandler[dict[str, Any] | str, LambdaContext, ReturnT]: ...
+
+
+@overload
+def event_parser(
+    handler: Callable[[Any, LambdaContext], ReturnT],
+    /,
+) -> LambdaHandler[dict[str, Any] | str, LambdaContext, ReturnT]: ...
+
+
+@overload
+def event_parser(
+    *,
+    model: type[ModelT] | TypeAdapter[ModelT],
+    envelope: None = None,
+) -> _EventParserModelHandlerDecorator[ModelT]: ...
+
+
+@overload
+def event_parser(
+    *,
+    model: Any = None,
+    envelope: type[BaseEnvelope] | None = None,
+) -> _EventParserHandlerDecorator: ...
+
 
 @lambda_handler_decorator
 def event_parser(
 
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Protocol, TypeVar, overload
 
 from aws_lambda_powertools.middleware_factory import lambda_handler_decorator
 from aws_lambda_powertools.utilities import jmespath_utils
@@ -10,8 +10,69 @@
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+    from aws_lambda_powertools.shared.types import LambdaHandler
+
 logger = logging.getLogger(__name__)
 
+EventT = TypeVar("EventT")
+ContextT = TypeVar("ContextT")
+ReturnT = TypeVar("ReturnT")
+
+
+class _ValidatorHandlerDecorator(Protocol):
+    def __call__(
+        self,
+        handler: Callable[[EventT, ContextT], ReturnT],
+        /,
+    ) -> LambdaHandler[EventT, ContextT, ReturnT]: ...
+
+
+class _ValidatorEnvelopeHandlerDecorator(Protocol):
+    # The handler's event type is Any, as it can't be derived from the arguments, e.g.
+    # - @validator(envelope=envelopes.SQS)
+    def __call__(
+        self,
+        handler: Callable[[Any, ContextT], ReturnT],
+        /,
+    ) -> LambdaHandler[dict[str, Any] | str, ContextT, ReturnT]: ...
+
+
+@overload
+def validator(
+    handler: Callable[[EventT, ContextT], ReturnT],
+    /,
+) -> LambdaHandler[EventT, ContextT, ReturnT]: ...
+
+
+@overload
+def validator(
+    *,
+    inbound_schema: dict | None = None,
+    inbound_formats: dict | None = None,
+    inbound_handlers: dict | None = None,
+    inbound_provider_options: dict | None = None,
+    outbound_schema: dict | None = None,
+    outbound_formats: dict | None = None,
+    outbound_handlers: dict | None = None,
+    outbound_provider_options: dict | None = None,
+) -> _ValidatorHandlerDecorator: ...
+
+
+@overload
+def validator(
+    *,
+    inbound_schema: dict | None = None,
+    inbound_formats: dict | None = None,
+    inbound_handlers: dict | None = None,
+    inbound_provider_options: dict | None = None,
+    outbound_schema: dict | None = None,
+    outbound_formats: dict | None = None,
+    outbound_handlers: dict | None = None,
+    outbound_provider_options: dict | None = None,
+    envelope: str,
+    jmespath_options: dict | None = None,
+) -> _ValidatorEnvelopeHandlerDecorator: ...
+
 
 @lambda_handler_decorator
 def validator(
 
@@ -1054,14 +1054,17 @@ Explore how to handle conditional write errors in high-concurrency scenarios wit
 
 The idempotency utility provides several routes to test your code.
 
+???+ tip "Type-checked tests"
+    The `idempotent` decorator is typed, so a decorated handler expects a `LambdaContext` as its second argument. When you use a lightweight fake context in tests, as in the examples below, `cast` it to `LambdaContext` to keep your type checker happy. Runtime behaviour is unchanged.
+
 ### Disabling the idempotency utility
 
 When testing your code, you may wish to disable the idempotency logic altogether and focus on testing your business logic. To do this, you can set the environment variable `POWERTOOLS_IDEMPOTENCY_DISABLED`
 with a truthy value. If you prefer setting this for specific tests, and are using Pytest, you can use [monkeypatch](https://docs.pytest.org/en/latest/monkeypatch.html){target="_blank" rel="nofollow"} fixture:
 
 === "test_disabling_idempotency_utility.py"
 
-    ```python hl_lines="3 4 23 24"
+    ```python hl_lines="4 5 23 26 28"
     --8<-- "examples/idempotency/tests/test_disabling_idempotency_utility.py"
     ```
 
@@ -1077,7 +1080,7 @@ To test with [DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/
 
 === "test_with_dynamodb_local.py"
 
-    ```python hl_lines="3-5 25 26"
+    ```python hl_lines="4 5 6 24 29 30"
     --8<-- "examples/idempotency/tests/test_with_dynamodb_local.py"
     ```
 
@@ -1094,7 +1097,7 @@ This means it is possible to pass a mocked Table resource, or stub various metho
 
 === "test_with_io_operations.py"
 
-    ```python hl_lines="4 5 24 25 27"
+    ```python hl_lines="5 6 24 28 29 31"
     --8<-- "examples/idempotency/tests/test_with_io_operations.py"
     ```
 
@@ -1110,7 +1113,7 @@ To test locally, you can either utilize [fakeredis-py](https://github.com/cunla/
 
 === "test_with_mock_redis.py"
 
-    ```python hl_lines="2 3 29 31"
+    ```python hl_lines="3 4 30 32"
     --8<-- "examples/idempotency/tests/test_with_mock_redis.py"
     ```
 
@@ -1124,7 +1127,7 @@ If you want to set up a real Redis client for integration testing, you can refer
 
 === "test_with_real_redis.py"
 
-    ```python hl_lines="3 4 29 38"
+    ```python hl_lines="4 5 30 39"
     --8<-- "examples/idempotency/tests/test_with_real_redis.py"
     ```
 
 
@@ -1,11 +1,14 @@
 from dataclasses import dataclass
+from typing import cast
 
 import app_test_disabling_idempotency_utility
 import pytest
 
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
 
 @dataclass
-class LambdaContext:
+class FakeLambdaContext:
     function_name: str = "test"
     memory_limit_in_mb: int = 128
     invoked_function_arn: str = "arn:aws:lambda:eu-west-1:809313241:function:test"
@@ -17,7 +20,7 @@ def get_remaining_time_in_millis(self) -> int:
 
 @pytest.fixture
 def lambda_context() -> LambdaContext:
-    return LambdaContext()
+    return cast(LambdaContext, FakeLambdaContext())
 
 
 def test_idempotent_lambda_handler(monkeypatch, lambda_context: LambdaContext):