value-object-pattern 0.1.0__py3-none-any.whl

value_object_pattern/usables/dates/datetime/string_datetime_value_object.py

@@ -0,0 +1,237 @@
+"""
+StringDatetimeValueObject value object.
+"""
+
+from datetime import UTC, datetime
+
+from dateutil.parser import ParserError, parse
+from dateutil.relativedelta import relativedelta
+
+from value_object_pattern.decorators import process, validation
+from value_object_pattern.usables import NotEmptyStringValueObject, TrimmedStringValueObject
+
+from .datetime_value_object import DatetimeValueObject
+
+
+class StringDatetimeValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    StringDatetimeValueObject value object ensures the provided value is a valid datetime.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.dates import StringDatetimeValueObject
+
+    now = '1900-01-01T00:00:00+00:00'
+    date = StringDatetimeValueObject(value=now)
+
+    print(repr(date))
+    # >>> StringDatetimeValueObject(value=1900-01-01T00:00:00+00:00)
+    ```
+    """
+
+    @process(order=0)
+    def _ensure_value_is_normalized(self, value: str) -> str:
+        """
+        Ensures the value object value is normalized datetime string (ISO 8601, YYYY-MM-DDTHH:MM:SS).
+
+        Args:
+            value (str): Value.
+
+        Returns:
+            str: Value with the normalized datetime string.
+        """
+        return self._datetime_normalize(value=value).isoformat()
+
+    @validation(order=0)
+    def _ensure_value_is_date(self, value: str) -> None:
+        """
+        Ensures the value object value is a datetime.
+
+        Args:
+            value (str): Value.
+
+        Raises:
+            ValueError: If the value is not a datetime.
+        """
+        self._datetime_normalize(value=value)
+
+    @classmethod
+    def _datetime_normalize(cls, value: str) -> datetime:
+        """
+        Normalizes the given datetime.
+
+        Args:
+            value (str): datetime.
+
+        Raises:
+            TypeError: If the value is not a string.
+            ValueError: If the value is not a valid datetime.
+
+        Returns:
+            str: Normalized datetime.
+        """
+        if type(value) is not str:
+            raise TypeError(f'StringDatetimeValueObject value <<<{value}>>> must be a string. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip
+
+        try:
+            return parse(timestr=value).astimezone(tz=UTC)
+
+        except ParserError as error:
+            raise ValueError(f'StringDatetimeValueObject value <<<{value}>>> is not a valid datetime.') from error
+
+    def is_now(self, *, reference_datetime: datetime | None = None) -> bool:
+        """
+        Determines whether the stored datetime value matches the current datetime.
+
+        Args:
+            reference_datetime (datetime | None, optional): The datetime to compare against. If None, the current
+            datetime (UTC) is used.
+
+        Raises:
+            TypeError: If the reference_datetime is not a datetime.
+
+        Returns:
+            bool: True if the stored datetime matches the current datetime, False otherwise.
+
+        Example:
+        ```python
+        from datetime import UTC, datetime
+
+        from value_object_pattern.usables.dates import StringDatetimeValueObject
+
+        now = '1900-01-01T08:30:00+00:00'
+        today = datetime(year=1900, month=1, day=1, hour=0, minute=0, second=0, tzinfo=UTC)
+        is_now = StringDatetimeValueObject(value=now).is_now(reference_datetime=today)
+
+        print(is_now)
+        # >>> False
+        ```
+        """
+        if reference_datetime is None:
+            reference_datetime = datetime.now(tz=UTC)
+
+        date_value = self._datetime_normalize(value=self.value)
+        DatetimeValueObject(value=reference_datetime)
+
+        return date_value == reference_datetime
+
+    def is_today(self, *, reference_datetime: datetime | None = None) -> bool:
+        """
+        Determines whether the stored datetime value is today's datetime.
+
+        Args:
+            reference_datetime (datetime | None, optional): The datetime to compare against. If None, the current
+            datetime (UTC) is used.
+
+        Raises:
+            TypeError: If the reference_datetime is not a datetime.
+
+        Returns:
+            bool: True if the stored datetime matches today's datetime, False otherwise.
+
+        Example:
+        ```python
+        from datetime import UTC, datetime
+
+        from value_object_pattern.usables.dates import StringDatetimeValueObject
+
+        now = '1900-01-01T08:30:00+00:00'
+        today = datetime(year=1900, month=1, day=1, hour=0, minute=0, second=0, tzinfo=UTC)
+        is_today = StringDatetimeValueObject(value=now).is_today(reference_datetime=today)
+
+        print(is_today)
+        # >>> True
+        ```
+        """
+        if reference_datetime is None:
+            reference_datetime = datetime.now(tz=UTC)
+
+        date_value = self._datetime_normalize(value=self.value)
+        DatetimeValueObject(value=reference_datetime)
+
+        return date_value.date() == reference_datetime.date()
+
+    def is_in_range(self, *, start_datetime: datetime, end_datetime: datetime) -> bool:
+        """
+        Determines whether the stored datetime value falls within the specified datetime range.
+
+        Args:
+            start_datetime (datetime): The beginning of the datetime range (inclusive).
+            end_datetime (datetime): The end of the datetime range (inclusive).
+
+        Raises:
+            TypeError: If start_datetime is not a datetime.
+            TypeError: If end_datetime is not a datetime.
+            ValueError: If start_datetime is later than end_datetime.
+
+        Returns:
+            bool: True if the stored datetime is within the range, False otherwise.
+
+        Example:
+        ```python
+        from datetime import UTC, datetime
+
+        from value_object_pattern.usables.dates import StringDatetimeValueObject
+
+        now = '1900-01-01T00:00:00+00:00'
+        start_datetime = datetime(year=1899, month=12, day=31, hour=23, minute=59, second=59, tzinfo=UTC)
+        end_datetime = datetime(year=1900, month=1, day=2, hour=00, minute=00, second=00, tzinfo=UTC)
+        is_in_range = StringDatetimeValueObject(
+            value=now,
+        ).is_in_range(
+            start_datetime=start_datetime,
+            end_datetime=end_datetime,
+        )
+
+        print(is_in_range)
+        # >>> True
+        ```
+        """
+        date_value = self._datetime_normalize(value=self.value)
+        DatetimeValueObject(value=start_datetime)
+        DatetimeValueObject(value=end_datetime)
+
+        if start_datetime > end_datetime:
+            raise ValueError(f'StringDatetimeValueObject start_datetime <<<{start_datetime.isoformat()}>>> must be earlier than or equal to end_datetime <<<{end_datetime.isoformat()}>>>.')  # noqa: E501  # fmt: skip
+
+        return start_datetime <= date_value <= end_datetime
+
+    def calculate_age(self, *, reference_datetime: datetime | None = None) -> int:
+        """
+        Calculates the age of the stored datetime value.
+
+        Args:
+            reference_datetime (datetime | None, optional): The datetime to calculate the age against. If None, the
+            current datetime (UTC) is used.
+
+        Raises:
+            TypeError: If the reference_datetime is not a datetime.
+            ValueError: If the stored datetime is later than the reference_datetime.
+
+        Returns:
+            int: The age in years of the stored datetime.
+
+        Example:
+        ```python
+        from datetime import UTC, datetime
+
+        from value_object_pattern.usables.dates import StringDatetimeValueObject
+
+        now = '1900-01-01T00:00:00+00:00'
+        today = datetime(year=2000, month=1, day=1, hour=0, minute=0, second=0, tzinfo=UTC)
+        age = StringDatetimeValueObject(value=now).calculate_age(reference_datetime=today)
+
+        print(age)
+        # >>> 100
+        ```
+        """
+        if reference_datetime is None:
+            reference_datetime = datetime.now(tz=UTC)
+
+        datetime_value = self._datetime_normalize(value=self.value)
+        DatetimeValueObject(value=reference_datetime)
+
+        if datetime_value > reference_datetime:
+            raise ValueError(f'StringDatetimeValueObject value <<<{datetime_value.isoformat()}>>> must be earlier than or equal to reference_datetime <<<{reference_datetime.isoformat()}>>>.')  # noqa: E501  # fmt: skip
+
+        return relativedelta(dt1=reference_datetime, dt2=datetime_value).years

value_object_pattern/usables/identifiers/__init__.py

@@ -0,0 +1,7 @@
+from .string_uuid_value_object import StringUuidValueObject
+from .uuid_value_object import UuidValueObject
+
+__all__ = (
+    'StringUuidValueObject',
+    'UuidValueObject',
+)

value_object_pattern/usables/identifiers/country_ids/__init__.py

@@ -0,0 +1,3 @@
+from .spain import DniValueObject
+
+__all__ = ('DniValueObject',)

value_object_pattern/usables/identifiers/country_ids/spain/__init__.py

@@ -0,0 +1,3 @@
+from .dni_value_object import DniValueObject
+
+__all__ = ('DniValueObject',)

value_object_pattern/usables/identifiers/country_ids/spain/dni_value_object.py

@@ -0,0 +1,63 @@
+"""
+DniValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+
+from value_object_pattern.decorators import process, validation
+from value_object_pattern.usables import NotEmptyStringValueObject, TrimmedStringValueObject
+
+
+class DniValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    DniValueObject value object ensures the provided value is a valid Spanish DNI.
+    A Spanish DNI is a string with 9 characters. The first 8 characters are numbers and the last character is a letter.
+    The letter is calculated using the number modulo 23 and the result is compared with a predefined list of letters.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.identifiers.country_ids import DniValueObject
+
+    dni = DniValueObject(value='87654321X')
+
+    print(repr(dni))
+    # >>> DniValueObject(value=87654321X)
+    ```
+    """
+
+    __DNI_VALUE_OBJECT_LETTERS: str = 'TRWAGMYFPDXBNJZSQVHLCKE'
+    __DNI_VALUE_OBJECT_REGEX: Pattern[str] = re_compile(pattern=r'([0-9]{8})([a-zA-Z])')
+
+    @process(order=0)
+    def _ensure_value_is_upper(self, value: str) -> str:
+        """
+        Ensures the value object `value` is an upper string.
+
+        Args:
+            value (str): The provided value.
+
+        Returns:
+            str: Upper case value.
+        """
+        return value.upper()
+
+    @validation(order=0)
+    def _ensure_value_is_dni(self, value: str) -> None:
+        """
+        Ensures the value object `value` is a Spanish DNI.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not a Spanish DNI.
+        """
+        match = self.__DNI_VALUE_OBJECT_REGEX.fullmatch(string=value)
+        if not match:
+            raise ValueError(f'DniValueObject value <<<{value}>>> is not a valid Spanish DNI.')
+
+        number, letter = match.groups()
+
+        expected_letter = self.__DNI_VALUE_OBJECT_LETTERS[int(number) % 23]
+        if letter.upper() != expected_letter:
+            raise ValueError(f'DniValueObject value <<<{value}>>> is not a valid Spanish DNI.')

value_object_pattern/usables/identifiers/string_uuid_value_object.py

@@ -0,0 +1,56 @@
+"""
+StringUuidValueObject value object.
+"""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+from value_object_pattern.decorators import process, validation
+from value_object_pattern.usables import NotEmptyStringValueObject, TrimmedStringValueObject
+
+
+class StringUuidValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    StringUuidValueObject value object ensures the provided value is a valid UUID.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.identifiers import StringUuidValueObject
+
+    uuid = StringUuidValueObject(value='9908bb2d-54b4-426f-bef0-b09aa978ed21')
+
+    print(repr(uuid))
+    # >>> StringUuidValueObject(value=9908bb2d-54b4-426f-bef0-b09aa978ed21)
+    ```
+    """
+
+    @process(order=0)
+    def _ensure_value_is_lower(self, value: str) -> str:
+        """
+        Ensures the value object `value` is lower UUID string.
+
+        Args:
+            value (str): The provided value.
+
+        Returns:
+            str: Value with the lower UUID string.
+        """
+        return value.lower()
+
+    @validation(order=0)
+    def _ensure_value_is_uuid(self, value: str) -> None:
+        """
+        Ensures the value object `value` is a UUID.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not a UUID.
+        """
+        try:
+            UUID(hex=value)
+
+        except ValueError as error:
+            raise ValueError(f'StringUuidValueObject value <<<{value}>>> is not a valid UUID.') from error

value_object_pattern/usables/identifiers/uuid_value_object.py

@@ -0,0 +1,40 @@
+"""
+UuidValueObject value object.
+"""
+
+from uuid import UUID
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.models import ValueObject
+
+
+class UuidValueObject(ValueObject[UUID]):
+    """
+    UuidValueObject value object ensures the provided value is a valid UUID.
+
+    Example:
+    ```python
+    from uuid import uuid4
+
+    from value_object_pattern.usables.identifiers import UuidValueObject
+
+    uuid = UuidValueObject(value=uuid4())
+
+    print(repr(uuid))
+    # >>> UuidValueObject(value=9908bb2d-54b4-426f-bef0-b09aa978ed21)
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_uuid(self, value: UUID) -> None:
+        """
+        Ensures the value object `value` is a UUID.
+
+        Args:
+            value (UUID): The provided value.
+
+        Raises:
+            TypeError: If the `value` is not a UUID.
+        """
+        if type(value) is not UUID:
+            raise TypeError(f'UuidValueObject value <<<{value}>>> must be a UUID. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip

value_object_pattern/usables/internet/__init__.py

@@ -0,0 +1,38 @@
+from .api_keys import (
+    AwsAccessKeyValueObject,
+    AwsSecretAccessKeyValueObject,
+    GitHubPersonalAccessTokenValueObject,
+    OpenaiApiKeyValueObject,
+    ResendApiKeyValueObject,
+)
+from .aws_cloud_region_value_object import AwsCloudRegionValueObject
+from .domain_value_object import DomainValueObject
+from .host_value_object import HostValueObject
+from .ipv4_address_value_object import Ipv4AddressValueObject
+from .ipv4_network_value_object import Ipv4NetworkValueObject
+from .ipv6_address_value_object import Ipv6AddressValueObject
+from .ipv6_network_value_object import Ipv6NetworkValueObject
+from .mac_address_value_object import MacAddressValueObject
+from .port_value_object import PortValueObject
+from .uri import HttpHttpsUrlValueObject, HttpUrlValueObject, HttpsUrlValueObject, UrlValueObject
+
+__all__ = (
+    'AwsAccessKeyValueObject',
+    'AwsCloudRegionValueObject',
+    'AwsSecretAccessKeyValueObject',
+    'DomainValueObject',
+    'GitHubPersonalAccessTokenValueObject',
+    'HostValueObject',
+    'HttpHttpsUrlValueObject',
+    'HttpUrlValueObject',
+    'HttpsUrlValueObject',
+    'Ipv4AddressValueObject',
+    'Ipv4NetworkValueObject',
+    'Ipv6AddressValueObject',
+    'Ipv6NetworkValueObject',
+    'MacAddressValueObject',
+    'OpenaiApiKeyValueObject',
+    'PortValueObject',
+    'ResendApiKeyValueObject',
+    'UrlValueObject',
+)

value_object_pattern/usables/internet/api_keys/__init__.py

@@ -0,0 +1,13 @@
+from .aws_access_key_id_value_object import AwsAccessKeyValueObject
+from .aws_secret_access_key_value_object import AwsSecretAccessKeyValueObject
+from .github_personal_access_token_value_object import GitHubPersonalAccessTokenValueObject
+from .openai_api_key_value_object import OpenaiApiKeyValueObject
+from .resend_api_key_value_object import ResendApiKeyValueObject
+
+__all__ = (
+    'AwsAccessKeyValueObject',
+    'AwsSecretAccessKeyValueObject',
+    'GitHubPersonalAccessTokenValueObject',
+    'OpenaiApiKeyValueObject',
+    'ResendApiKeyValueObject',
+)

value_object_pattern/usables/internet/api_keys/aws_access_key_id_value_object.py

@@ -0,0 +1,40 @@
+"""
+AwsAccessKeyValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.usables import NotEmptyStringValueObject, TrimmedStringValueObject
+
+
+class AwsAccessKeyValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    AwsAccessKeyValueObject value object ensures the provided value is a valid AWS Access Key ID.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.internet import AwsAccessKeyValueObject
+
+    key = AwsAccessKeyValueObject(value='AKIAIOSFODNN7EXAMPLE')  # gitleaks:allow
+
+    print(repr(key))
+    # >>> AwsAccessKeyValueObject(value=AKIAIOSFODNN7EXAMPLE)  # gitleaks:allow
+    ```
+    """
+
+    __AWS_ACCESS_KEY_VALUE_OBJECT_REGEX: Pattern[str] = re_compile(pattern=r'^(AKIA|ASIA)[A-Z0-9]{16}$')
+
+    @validation(order=0)
+    def _ensure_value_is_valid_aws_access_key(self, value: str) -> None:
+        """
+        Ensures the value object value is a valid AWS Access Key ID.
+
+        Args:
+            value (str): Value.
+
+        Raises:
+            ValueError: If the value is not a valid AWS Access Key ID.
+        """
+        if not self.__AWS_ACCESS_KEY_VALUE_OBJECT_REGEX.fullmatch(string=value):
+            raise ValueError(f'AwsAccessKeyValueObject value <<<{value}>>> is not a valid AWS Access Key ID.')

value_object_pattern/usables/internet/api_keys/aws_secret_access_key_value_object.py

@@ -0,0 +1,40 @@
+"""
+AwsSecretAccessKeyValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.usables import NotEmptyStringValueObject, TrimmedStringValueObject
+
+
+class AwsSecretAccessKeyValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    AwsSecretAccessKeyValueObject value object ensures the provided value is a valid AWS Secret Access Key.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.internet import AwsSecretAccessKeyValueObject
+
+    key = AwsSecretAccessKeyValueObject(value='wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY')  # gitleaks:allow
+
+    print(repr(key))
+    # >>> AwsSecretAccessKeyValueObject(value=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY)  # gitleaks:allow
+    ```
+    """
+
+    __AWS_SECRET_ACCESS_KEY_VALUE_OBJECT_REGEX: Pattern[str] = re_compile(pattern=r'^[a-zA-Z0-9/+=]{40}$')
+
+    @validation(order=0)
+    def _ensure_value_is_valid_aws_secret_access_key(self, value: str) -> None:
+        """
+        Ensures the value object value is a valid AWS Secret Access Key.
+
+        Args:
+            value (str): Value.
+
+        Raises:
+            ValueError: If the value is not a valid AWS Secret Access Key.
+        """
+        if not self.__AWS_SECRET_ACCESS_KEY_VALUE_OBJECT_REGEX.fullmatch(string=value):
+            raise ValueError(f'AwsSecretAccessKeyValueObject value <<<{value}>>> is not a valid AWS Secret Access Key.')

value_object_pattern/usables/internet/api_keys/github_personal_access_token_value_object.py

@@ -0,0 +1,41 @@
+"""
+GitHubPersonalAccessTokenValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.usables import NotEmptyStringValueObject, TrimmedStringValueObject
+
+
+class GitHubPersonalAccessTokenValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    GitHubPersonalAccessTokenValueObject value object ensures the provided value is a valid GitHub Personal Access
+    Token.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.internet import GitHubPersonalAccessTokenValueObject
+
+    key = GitHubPersonalAccessTokenValueObject(value='ghp_cgq4ZrHmFu0lLPl7ajKAwgMPnT5zhF000000')  # gitleaks:allow
+
+    print(repr(key))
+    # >>> GitHubPersonalAccessTokenValueObject(value=ghp_cgq4ZrHmFu0lLPl7ajKAwgMPnT5zhF000000)  # gitleaks:allow
+    ```
+    """
+
+    __GITHUB_PERSONAL_ACCESS_TOKEN_VALUE_OBJECT_REGEX: Pattern[str] = re_compile(pattern=r'^ghp_[a-zA-Z0-9]{36}$')
+
+    @validation(order=0)
+    def _ensure_value_is_valid_github_pat(self, value: str) -> None:
+        """
+        Ensures the value object value is a valid GitHub Personal Access Token.
+
+        Args:
+            value (str): Value.
+
+        Raises:
+            ValueError: If the value is not a valid GitHub Personal Access Token
+        """
+        if not self.__GITHUB_PERSONAL_ACCESS_TOKEN_VALUE_OBJECT_REGEX.fullmatch(string=value):
+            raise ValueError(f'GitHubPersonalAccessTokenValueObject value <<<{value}>>> is not a valid GitHub Personal Access Token.')  # noqa: E501  # fmt: skip

value_object_pattern/usables/internet/api_keys/openai_api_key_value_object.py

@@ -0,0 +1,40 @@
+"""
+OpenaiApiKeyValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.usables import NotEmptyStringValueObject, TrimmedStringValueObject
+
+
+class OpenaiApiKeyValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    OpenaiApiKeyValueObject value object ensures the provided value is a valid OpenAI API Key.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.internet import OpenaiApiKeyValueObject
+
+    key = OpenaiApiKeyValueObject(value='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')  # gitleaks:allow
+
+    print(repr(key))
+    # >>> OpenaiApiKeyValueObject(value=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)  # gitleaks:allow
+    ```
+    """
+
+    __OPENAI_API_KEY_VALUE_OBJECT_REGEX: Pattern[str] = re_compile(pattern=r'^sk-[a-zA-Z0-9]{20}T3BlbkFJ[a-zA-Z0-9]{20}$')  # noqa: E501  # fmt: skip
+
+    @validation(order=0)
+    def _ensure_value_is_valid_openai_api_key(self, value: str) -> None:
+        """
+        Ensures the value object value is a valid OpenAI API Key.
+
+        Args:
+            value (str): Value.
+
+        Raises:
+            ValueError: If the value is not a valid OpenAI API Key.
+        """
+        if not self.__OPENAI_API_KEY_VALUE_OBJECT_REGEX.fullmatch(string=value):
+            raise ValueError(f'OpenaiApiKeyValueObject value <<<{value}>>> is not a valid OpenAI API Key.')

value_object_pattern/usables/internet/api_keys/resend_api_key_value_object.py

@@ -0,0 +1,40 @@
+"""
+ResendApiKeyValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.usables import NotEmptyStringValueObject, TrimmedStringValueObject
+
+
+class ResendApiKeyValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    ResendApiKeyValueObject value object ensures the provided value is a valid Resend API Key.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.internet import ResendApiKeyValueObject
+
+    key = ResendApiKeyValueObject(value='re_c1tpEyD8_NKFusih9vKVQknRAQfmFcWCv')  # gitleaks:allow
+
+    print(repr(key))
+    # >>> ResendApiKeyValueObject(value=re_c1tpEyD8_NKFusih9vKVQknRAQfmFcWCv)  # gitleaks:allow
+    ```
+    """
+
+    __RESEND_API_KEY_VALUE_OBJECT_REGEX: Pattern[str] = re_compile(pattern=r'^re_[a-zA-Z0-9-_]{30,}$')
+
+    @validation(order=0)
+    def _ensure_value_is_valid_resend_api_key(self, value: str) -> None:
+        """
+        Ensures the value object value is a valid Resend API Key.
+
+        Args:
+            value (str): Value.
+
+        Raises:
+            ValueError: If the value is not a valid Resend API Key.
+        """
+        if not self.__RESEND_API_KEY_VALUE_OBJECT_REGEX.fullmatch(string=value):
+            raise ValueError(f'ResendApiKeyValueObject value <<<{value}>>> is not a valid Resend API Key.')