brevo-python 4.0.1__py3-none-any.whl

brevo/domains/raw_client.py

@@ -0,0 +1,698 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from json.decoder import JSONDecodeError
+
+from ..core.api_error import ApiError
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.http_response import AsyncHttpResponse, HttpResponse
+from ..core.jsonable_encoder import jsonable_encoder
+from ..core.request_options import RequestOptions
+from ..core.unchecked_base_model import construct_type
+from ..errors.bad_request_error import BadRequestError
+from ..errors.not_found_error import NotFoundError
+from .types.authenticate_domain_response import AuthenticateDomainResponse
+from .types.create_domain_response import CreateDomainResponse
+from .types.get_domain_configuration_response import GetDomainConfigurationResponse
+from .types.get_domains_response import GetDomainsResponse
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class RawDomainsClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def get_domains(
+        self, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[GetDomainsResponse]:
+        """
+        Retrieves all domains associated with the account.
+
+        Use this to:
+        - List all domains
+        - Verify domain existence
+        - Check domain authentication and verification status
+        - Monitor domain configuration and provider information
+        - Review domain creation history and ownership
+
+        Key information returned:
+        - Domain details (ID, name, authentication status)
+        - Verification and authentication states
+        - Associated IP addresses and DNS providers
+        - Creator information and creation timestamps
+        - Pagination information for large domain lists
+
+        Parameters
+        ----------
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[GetDomainsResponse]
+            List of domains retrieved successfully
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "senders/domains",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    GetDomainsResponse,
+                    construct_type(
+                        type_=GetDomainsResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def create_domain(
+        self, *, name: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[CreateDomainResponse]:
+        """
+        Creates a new domain in Brevo.
+
+        Use this to:
+        - Add new domains for sending emails
+        - Set up domain authentication for better deliverability
+        - Configure DNS records for email authentication
+        - Establish domain-based sender identities
+
+        Key information returned:
+        - Created domain ID and configuration
+        - Required DNS records for authentication
+        - Domain provider detection results
+        - Setup instructions and next steps
+
+        Parameters
+        ----------
+        name : str
+            Domain name to be added
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[CreateDomainResponse]
+            Domain created successfully
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "senders/domains",
+            method="POST",
+            json={
+                "name": name,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    CreateDomainResponse,
+                    construct_type(
+                        type_=CreateDomainResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def get_domain_configuration(
+        self, domain_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[GetDomainConfigurationResponse]:
+        """
+        Retrieves configuration of a specific domain, to know if the domain is valid or not.
+
+        Use this to:
+        - Check domain configuration
+        - Validate a domain configuration
+        - Monitor DNS record status
+        - Troubleshoot authentication issues
+
+        Key information returned:
+        - Domain verification and authentication status
+        - DNS records configuration and validation status
+        - Detailed authentication requirements
+
+        Parameters
+        ----------
+        domain_name : str
+            Domain name
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[GetDomainConfigurationResponse]
+            Domain configuration retrieved successfully
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"senders/domains/{jsonable_encoder(domain_name)}",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    GetDomainConfigurationResponse,
+                    construct_type(
+                        type_=GetDomainConfigurationResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def delete_domain(
+        self, domain_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[None]:
+        """
+        Deletes a domain from Brevo.
+
+        Use this to:
+        - Remove existing domains
+        - Clean up unused domain configurations
+        - Remove test domains
+
+        Key information returned:
+        - Success confirmation message
+
+        Parameters
+        ----------
+        domain_name : str
+            Domain name
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[None]
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"senders/domains/{jsonable_encoder(domain_name)}",
+            method="DELETE",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return HttpResponse(response=_response, data=None)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def authenticate_domain(
+        self, domain_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[AuthenticateDomainResponse]:
+        """
+        Authenticates a specific domain.
+
+        Use this to:
+        - Authenticate a domain
+        - Verify DNS record configuration
+        - Complete domain setup for sending
+        - Enable domain for email authentication
+
+        Key information returned:
+        - Authentication success confirmation
+        - Domain readiness status for email sending
+
+        Parameters
+        ----------
+        domain_name : str
+            Domain name
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[AuthenticateDomainResponse]
+            Domain authenticated successfully
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"senders/domains/{jsonable_encoder(domain_name)}/authenticate",
+            method="PUT",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    AuthenticateDomainResponse,
+                    construct_type(
+                        type_=AuthenticateDomainResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+
+class AsyncRawDomainsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def get_domains(
+        self, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[GetDomainsResponse]:
+        """
+        Retrieves all domains associated with the account.
+
+        Use this to:
+        - List all domains
+        - Verify domain existence
+        - Check domain authentication and verification status
+        - Monitor domain configuration and provider information
+        - Review domain creation history and ownership
+
+        Key information returned:
+        - Domain details (ID, name, authentication status)
+        - Verification and authentication states
+        - Associated IP addresses and DNS providers
+        - Creator information and creation timestamps
+        - Pagination information for large domain lists
+
+        Parameters
+        ----------
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[GetDomainsResponse]
+            List of domains retrieved successfully
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "senders/domains",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    GetDomainsResponse,
+                    construct_type(
+                        type_=GetDomainsResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def create_domain(
+        self, *, name: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[CreateDomainResponse]:
+        """
+        Creates a new domain in Brevo.
+
+        Use this to:
+        - Add new domains for sending emails
+        - Set up domain authentication for better deliverability
+        - Configure DNS records for email authentication
+        - Establish domain-based sender identities
+
+        Key information returned:
+        - Created domain ID and configuration
+        - Required DNS records for authentication
+        - Domain provider detection results
+        - Setup instructions and next steps
+
+        Parameters
+        ----------
+        name : str
+            Domain name to be added
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[CreateDomainResponse]
+            Domain created successfully
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "senders/domains",
+            method="POST",
+            json={
+                "name": name,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    CreateDomainResponse,
+                    construct_type(
+                        type_=CreateDomainResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def get_domain_configuration(
+        self, domain_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[GetDomainConfigurationResponse]:
+        """
+        Retrieves configuration of a specific domain, to know if the domain is valid or not.
+
+        Use this to:
+        - Check domain configuration
+        - Validate a domain configuration
+        - Monitor DNS record status
+        - Troubleshoot authentication issues
+
+        Key information returned:
+        - Domain verification and authentication status
+        - DNS records configuration and validation status
+        - Detailed authentication requirements
+
+        Parameters
+        ----------
+        domain_name : str
+            Domain name
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[GetDomainConfigurationResponse]
+            Domain configuration retrieved successfully
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"senders/domains/{jsonable_encoder(domain_name)}",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    GetDomainConfigurationResponse,
+                    construct_type(
+                        type_=GetDomainConfigurationResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def delete_domain(
+        self, domain_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[None]:
+        """
+        Deletes a domain from Brevo.
+
+        Use this to:
+        - Remove existing domains
+        - Clean up unused domain configurations
+        - Remove test domains
+
+        Key information returned:
+        - Success confirmation message
+
+        Parameters
+        ----------
+        domain_name : str
+            Domain name
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[None]
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"senders/domains/{jsonable_encoder(domain_name)}",
+            method="DELETE",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return AsyncHttpResponse(response=_response, data=None)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def authenticate_domain(
+        self, domain_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[AuthenticateDomainResponse]:
+        """
+        Authenticates a specific domain.
+
+        Use this to:
+        - Authenticate a domain
+        - Verify DNS record configuration
+        - Complete domain setup for sending
+        - Enable domain for email authentication
+
+        Key information returned:
+        - Authentication success confirmation
+        - Domain readiness status for email sending
+
+        Parameters
+        ----------
+        domain_name : str
+            Domain name
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[AuthenticateDomainResponse]
+            Domain authenticated successfully
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"senders/domains/{jsonable_encoder(domain_name)}/authenticate",
+            method="PUT",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    AuthenticateDomainResponse,
+                    construct_type(
+                        type_=AuthenticateDomainResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        construct_type(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)