mms-client 1.7.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

mms_client/services/base.py

@@ -53,26 +53,33 @@ class ServiceConfiguration:
 
 
 @dataclass
-class EndpointConfiguration(Generic[E, P]):
+class EndpointConfiguration(Generic[E, P]):  # pylint: disable=too-many-instance-attributes
     """Configuration for an endpoint on the MMS server."""
 
     # The name of the endpoint
     name: str
 
-    # The allowed client types for the endpoint
-    allowed_clients: Optional[List[ClientType]]
-
     # The service for the endpoint
     service: ServiceConfiguration
 
     # The type of request to submit to the MMS server
     request_type: RequestType
 
+    # The allowed client types for the endpoint
+    allowed_clients: Optional[List[ClientType]] = None
+
     # The type of payload to expect in the response
-    response_envelope_type: Optional[Type[E]]
+    response_envelope_type: Optional[Type[E]] = None
 
     # The type of data to expect in the response
-    response_data_type: Optional[Type[P]]
+    response_data_type: Optional[Type[P]] = None
+
+    # Whether the endpoint is for a report request
+    for_report: bool = False
+
+    # An optional serializer used to deserialize the response data for the service. This is only used for report
+    # requests because they have a separate XSD file for responses.
+    serializer: Optional[Serializer] = None
 
 
 class ClientProto(Protocol):
@@ -86,6 +93,10 @@ class ClientProto(Protocol):
     def user(self) -> str:
         """Return the user name of the person making the request."""
 
+    @property
+    def client_type(self) -> ClientType:
+        """Return the type of client to use for making requests to the MMS server."""
+
     def verify_audience(self, config: EndpointConfiguration) -> None:
         """Verify that the client type is allowed.
 
@@ -132,14 +143,7 @@ class ClientProto(Protocol):
         """
 
 
-def mms_endpoint(
-    name: str,
-    service: ServiceConfiguration,
-    request_type: RequestType,
-    allowed_clients: Optional[List[ClientType]] = None,
-    resp_envelope_type: Optional[Type[E]] = None,
-    resp_data_type: Optional[Type[P]] = None,
-):
+def mms_endpoint(**kwargs):
     """Create a decorator for an MMS endpoint.
 
     This decorator is used to mark a method as an MMS endpoint. It will add the endpoint configuration to the function
@@ -152,13 +156,16 @@ def mms_endpoint(
     request_type (RequestType):         The type of request to submit to the MMS server.
     allowed_clients (List[ClientType]): The types of clients that are allowed to access the endpoint. If this is not
                                         provided, then any client will be allowed.
-    resp_envelope_type (Type[E]):       The type of payload to expect in the response. If this is not provided, then the
+    response_envelope_type (Type[E]):   The type of payload to expect in the response. If this is not provided, then the
                                         response envelope will be assumed to have the same type as the request envelope.
-    resp_data_type (Type[P]):           The type of data to expect in the response. If this is not provided, then the
+    response_data_type (Type[P]):       The type of data to expect in the response. If this is not provided, then the
                                         response data will be assumed to have the same type as the request data.
+    for_report (bool):                  If True, the endpoint is for a report request.
+    serializer (Serializer):            The serializer to use for responses from the endpoint. Overrides the default
+                                        serializer for the service.
     """
     # First, create the endpoint configuration from the given parameters
-    config = EndpointConfiguration(name, allowed_clients, service, request_type, resp_envelope_type, resp_data_type)
+    config = EndpointConfiguration(**kwargs)
 
     # Next, create a decorator that will add the endpoint configuration to the function
     def decorator(func):
@@ -169,10 +176,18 @@ def mms_endpoint(
             self.verify_audience(config)
 
             # Next, call the wrapped function to get the envelope
-            envelope = func(self, *args, **kwargs)
+            result = func(self, *args, **kwargs)
+            if isinstance(result, tuple):
+                envelope, callback = result
+            else:
+                envelope, callback = result, None
 
             # Now, submit the request to the MMS server and get the response
-            resp, _ = self.request_one(envelope, args[0], config)
+            resp, attachments = self.request_one(envelope, args[0], config)
+
+            # Call the callback function if it was provided
+            if callback:
+                callback(resp, attachments)
 
             # Finally, extract the data from the response and return it
             logger.info(f"{config.name}: Returning {type(resp.data).__name__} data.")
@@ -184,14 +199,7 @@ def mms_endpoint(
     return decorator
 
 
-def mms_multi_endpoint(
-    name: str,
-    service: ServiceConfiguration,
-    request_type: RequestType,
-    allowed_clients: Optional[List[ClientType]] = None,
-    resp_envelope_type: Optional[Type[E]] = None,
-    resp_data_type: Optional[Type[P]] = None,
-):
+def mms_multi_endpoint(**kwargs):
     """Create a decorator for an MMS multi-response endpoint.
 
     This decorator is used to mark a method as an MMS multi-response endpoint. It will add the endpoint configuration to
@@ -205,17 +213,20 @@ def mms_multi_endpoint(
     request_type (RequestType):         The type of request to submit to the MMS server.
     allowed_clients (List[ClientType]): The types of clients that are allowed to access the endpoint. If this is not
                                         provided, then any client will be allowed.
-    resp_envelope_type (Type[E]):       The type of payload to expect in the response. If this is not provided, then
+    response_envelope_type (Type[E]):   The type of payload to expect in the response. If this is not provided, then
                                         the response envelope will be assumed to have the same type as the request
                                         envelope.
-    resp_data_type (Type[P]):           The type of data to expect in the response. If this is not provided, then the
+    response_data_type (Type[P]):       The type of data to expect in the response. If this is not provided, then the
                                         response data will be assumed to have the same type as the request data. Note,
                                         that this is not intended to account for the expected sequence type of the
                                         response data. That is already handled in the wrapped function, so this should
                                         only be set if the inner data type being returned differs from what was sent.
+    for_report (bool):                  If True, the endpoint is for a report request.
+    serializer (Serializer):            The serializer to use for responses from the endpoint. Overrides the default
+                                        serializer for the service.
     """
     # First, create the endpoint configuration from the given parameters
-    config = EndpointConfiguration(name, allowed_clients, service, request_type, resp_envelope_type, resp_data_type)
+    config = EndpointConfiguration(**kwargs)
 
     # Next, create a decorator that will add the endpoint configuration to the function
     def decorator(func):
@@ -226,10 +237,18 @@ def mms_multi_endpoint(
             self.verify_audience(config)
 
             # Next, call the wrapped function to get the envelope
-            envelope = func(self, *args, **kwargs)
+            result = func(self, *args, **kwargs)
+            if isinstance(result, tuple):
+                envelope, callback = result  # pragma: no cover
+            else:
+                envelope, callback = result, None
 
             # Now, submit the request to the MMS server and get the response
-            resp, _ = self.request_many(envelope, args[0], config)
+            resp, attachments = self.request_many(envelope, args[0], config)
+
+            # Call the callback function if it was provided
+            if callback:
+                callback(resp, attachments)  # pragma: no cover
 
             # Finally, extract the data from the response and return it
             logger.info(f"{config.name}: Returning {len(resp.data)} item(s).")
@@ -299,6 +318,11 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         """Return the user name of the person making the request."""
         return self._user
 
+    @property
+    def client_type(self) -> ClientType:
+        """Return the type of client to use for making requests to the MMS server."""
+        return self._client_type
+
     def verify_audience(self, config: EndpointConfiguration) -> None:
         """Verify that the client type is allowed.
 
@@ -341,7 +365,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
             f"{config.name}: Starting request. Envelope: {type(envelope).__name__}, Data: {type(payload).__name__}",
         )
         request = self._to_mms_request(
-            wrapper, config.request_type, config.service.serializer.serialize(envelope, payload)
+            wrapper, config.request_type, config.service.serializer.serialize(envelope, payload, config.for_report)
         )
 
         # Next, submit the request to the MMS server and get and verify the response.
@@ -354,7 +378,8 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         # Finally, deserialize and verify the response
         envelope_type = config.response_envelope_type or type(envelope)
         data_type = config.response_data_type or type(payload)
-        data: Response[E, P] = config.service.serializer.deserialize(resp.payload, envelope_type, data_type)
+        deserializer = config.serializer or config.service.serializer
+        data: Response[E, P] = deserializer.deserialize(resp.payload, envelope_type, data_type, config.for_report)
         self._verify_response(data, config)
 
         # Return the response data and any attachments
@@ -391,9 +416,11 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
             ),
         )
         serialized = (
-            config.service.serializer.serialize_multi(envelope, payload, data_type)  # type: ignore[arg-type]
+            config.service.serializer.serialize_multi(
+                envelope, payload, data_type, config.for_report  # type: ignore[arg-type]
+            )
             if is_list
-            else config.service.serializer.serialize(envelope, payload)  # type: ignore[type-var]
+            else config.service.serializer.serialize(envelope, payload, config.for_report)  # type: ignore[type-var]
         )
         request = self._to_mms_request(wrapper, config.request_type, serialized)
 
@@ -407,10 +434,12 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         # Finally, deserialize and verify the response
         envelope_type = config.response_envelope_type or type(envelope)
         data_type = config.response_data_type or data_type
-        data: MultiResponse[E, P] = config.service.serializer.deserialize_multi(
+        deserializer = config.serializer or config.service.serializer
+        data: MultiResponse[E, P] = deserializer.deserialize_multi(
             resp.payload,
             envelope_type,
             data_type,  # type: ignore[arg-type]
+            config.for_report,
         )
         self._verify_multi_response(data, config)
 
@@ -574,18 +603,18 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         Returns:    True to indicate that the response is valid, False otherwise.
         """
         # Log the request's processing statistics
-        logger.info(
-            f"{config.name} ({resp.statistics.timestamp_xml}): Recieved {resp.statistics.received}, "
-            f"Valid: {resp.statistics.valid}, Invalid: {resp.statistics.invalid}, "
-            f"Successful: {resp.statistics.successful}, Unsuccessful: {resp.statistics.unsuccessful} "
-            f"in {resp.statistics.time_ms}ms"
-        )
+        if resp.statistics is not None:
+            logger.info(
+                f"{config.name} ({resp.statistics.timestamp_xml}): Recieved {resp.statistics.received}, "
+                f"Valid: {resp.statistics.valid}, Invalid: {resp.statistics.invalid}, "
+                f"Successful: {resp.statistics.successful}, Unsuccessful: {resp.statistics.unsuccessful} "
+                f"in {resp.statistics.time_ms}ms"
+            )
 
         # Check if the response is invalid and if the envelope had any validation issues. If not, then we have a
         # valid base response so return True. Otherwise, return False.
-        return resp.statistics.invalid == 0 and self._verify_response_common(
-            config, type(resp.envelope), resp.envelope_validation
-        )
+        is_invalid = resp.statistics is not None and resp.statistics.invalid
+        return not is_invalid and self._verify_response_common(config, type(resp.envelope), resp.envelope_validation)
 
     def _verify_messages(self, config: EndpointConfiguration, resp: BaseResponse[E]) -> None:
         """Verify the messages in the given response.
@@ -595,12 +624,12 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         resp (BaseResponse):            The response to verify.
         """
         for path, messages in resp.messages.items():
-            for info in messages.information:
-                logger.info(f"{config.name} - {path}: {info.code}")
-            for warning in messages.warnings:
-                logger.warning(f"{config.name} - {path}: {warning.code}")
-            for error in messages.errors:
-                logger.error(f"{config.name} - {path}: {error.code}")
+            for info in messages.information:  # type: ignore[union-attr]
+                logger.info(f"{config.name} - {path}: {info}")
+            for warning in messages.warnings:  # type: ignore[union-attr]
+                logger.warning(f"{config.name} - {path}: {warning}")
+            for error in messages.errors:  # type: ignore[union-attr]
+                logger.error(f"{config.name} - {path}: {error}")
 
     def _verify_response_common(
         self, config: EndpointConfiguration, payload_type: type, resp: ResponseCommon, index: Optional[int] = None

mms_client/services/market.py

@@ -37,11 +37,11 @@ class MarketClientMixin:  # pylint: disable=unused-argument
     config = ServiceConfiguration(Interface.MI, Serializer(SchemaType.MARKET, "MarketData"))
 
     @mms_endpoint(
-        "MarketQuery_ReserveRequirementQuery",
-        config,
-        RequestType.INFO,
-        resp_envelope_type=MarketSubmit,
-        resp_data_type=ReserveRequirement,
+        name="MarketQuery_ReserveRequirementQuery",
+        service=config,
+        request_type=RequestType.INFO,
+        response_envelope_type=MarketSubmit,
+        response_data_type=ReserveRequirement,
     )
     def query_reserve_requirements(
         self: ClientProto, request: ReserveRequirementQuery, days: int, date: Optional[Date] = None
@@ -66,7 +66,9 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_endpoint("MarketSubmit_OfferData", config, RequestType.INFO, [ClientType.BSP])
+    @mms_endpoint(
+        name="MarketSubmit_OfferData", service=config, request_type=RequestType.MARKET, allowed_clients=[ClientType.BSP]
+    )
     def put_offer(
         self: ClientProto, request: OfferData, market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> OfferData:
@@ -92,7 +94,9 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_multi_endpoint("MarketSubmit_OfferData", config, RequestType.INFO, [ClientType.BSP])
+    @mms_multi_endpoint(
+        name="MarketSubmit_OfferData", service=config, request_type=RequestType.MARKET, allowed_clients=[ClientType.BSP]
+    )
     def put_offers(
         self: ClientProto, requests: List[OfferData], market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> List[OfferData]:
@@ -119,7 +123,11 @@ class MarketClientMixin:  # pylint: disable=unused-argument
         )
 
     @mms_multi_endpoint(
-        "MarketQuery_OfferQuery", config, RequestType.INFO, resp_envelope_type=MarketSubmit, resp_data_type=OfferData
+        name="MarketQuery_OfferQuery",
+        service=config,
+        request_type=RequestType.MARKET,
+        response_envelope_type=MarketSubmit,
+        response_data_type=OfferData,
     )
     def query_offers(self: ClientProto, request: OfferQuery, days: int, date: Optional[Date] = None) -> List[OfferData]:
         """Query the MMS server for offers.
@@ -142,7 +150,12 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_endpoint("MarketCancel_OfferCancel", config, RequestType.INFO, [ClientType.BSP])
+    @mms_endpoint(
+        name="MarketCancel_OfferCancel",
+        service=config,
+        request_type=RequestType.MARKET,
+        allowed_clients=[ClientType.BSP],
+    )
     def cancel_offer(
         self: ClientProto, request: OfferCancel, market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> OfferCancel:
@@ -168,7 +181,12 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_endpoint("MarketQuery_AwardResultsQuery", config, RequestType.MARKET, resp_data_type=AwardResponse)
+    @mms_endpoint(
+        name="MarketQuery_AwardResultsQuery",
+        service=config,
+        request_type=RequestType.MARKET,
+        response_data_type=AwardResponse,
+    )
     def query_awards(self: ClientProto, request: AwardQuery, days: int, date: Optional[Date] = None) -> AwardResponse:
         """Query the MMS server for award results.
 

mms_client/services/registration.py

@@ -10,7 +10,6 @@ from mms_client.services.base import ServiceConfiguration
 from mms_client.services.base import mms_endpoint
 from mms_client.services.base import mms_multi_endpoint
 from mms_client.types.registration import QueryAction
-from mms_client.types.registration import QueryType
 from mms_client.types.registration import RegistrationQuery
 from mms_client.types.registration import RegistrationSubmit
 from mms_client.types.resource import ResourceData
@@ -31,7 +30,12 @@ class RegistrationClientMixin:  # pylint: disable=unused-argument
     # The configuration for the registration service
     config = ServiceConfiguration(Interface.MI, Serializer(SchemaType.REGISTRATION, "RegistrationData"))
 
-    @mms_endpoint("RegistrationSubmit_Resource", config, RequestType.REGISTRATION, [ClientType.BSP])
+    @mms_endpoint(
+        name="RegistrationSubmit_Resource",
+        service=config,
+        request_type=RequestType.REGISTRATION,
+        allowed_clients=[ClientType.BSP],
+    )
     def put_resource(self: ClientProto, request: ResourceData) -> ResourceData:
         """Submit a new resource to the MMS server.
 
@@ -51,12 +55,12 @@ class RegistrationClientMixin:  # pylint: disable=unused-argument
         return RegistrationSubmit()  # type: ignore[return-value]
 
     @mms_multi_endpoint(
-        "RegistrationQuery_Resource",
-        config,
-        RequestType.REGISTRATION,
+        name="RegistrationQuery_Resource",
+        service=config,
+        request_type=RequestType.REGISTRATION,
         allowed_clients=[ClientType.BSP, ClientType.TSO],
-        resp_envelope_type=RegistrationSubmit,
-        resp_data_type=ResourceData,
+        response_envelope_type=RegistrationSubmit,
+        response_data_type=ResourceData,
     )
     def query_resources(
         self: ClientProto, request: ResourceQuery, action: QueryAction, date: Optional[Date] = None
@@ -79,6 +83,5 @@ class RegistrationClientMixin:  # pylint: disable=unused-argument
         # Inject our parameters into the query and return it.
         return RegistrationQuery(  # type: ignore[return-value]
             action=action,
-            query_type=QueryType.TRADE,
-            date=date or Date.today(),
+            date=date,
         )

mms_client/services/report.py

@@ -1,18 +1,161 @@
 """Contains the client layer for making report requests to the MMS server."""
 
 from logging import getLogger
+from typing import Dict
+from typing import List
+from typing import Type
+from typing import TypeVar
 
+from mms_client.services.base import ClientProto
 from mms_client.services.base import ServiceConfiguration
+from mms_client.services.base import mms_endpoint
+from mms_client.services.base import mms_multi_endpoint
+from mms_client.types.base import Response
+from mms_client.types.report import ApplicationType
+from mms_client.types.report import BSPResourceListItem
+from mms_client.types.report import ListReportRequest
+from mms_client.types.report import ListReportResponse
+from mms_client.types.report import NewReportRequest
+from mms_client.types.report import NewReportResponse
+from mms_client.types.report import OutboundData
+from mms_client.types.report import ReportBase
+from mms_client.types.report import ReportDownloadRequestTrnID
+from mms_client.types.report import ReportLineBase
+from mms_client.types.transport import RequestType
 from mms_client.utils.serialization import SchemaType
 from mms_client.utils.serialization import Serializer
+from mms_client.utils.web import ClientType
 from mms_client.utils.web import Interface
 
 # Set the default logger for the MMS client
 logger = getLogger(__name__)
 
 
+# The type variable we'll use to represent report line items
+R = TypeVar("R", bound=ReportLineBase)
+
+
+def attach_transaction_id(
+    resp: Response[ReportBase, NewReportResponse],
+    attachments: Dict[str, bytes],  # pylint: disable=unused-argument
+) -> None:
+    """Attach the transaction ID to the response.
+
+    Arguments:
+    resp (Response[ReportBase, NewReportResponse]): The MMS response.
+    attachments (Dict[str, bytes]):                 Attachements to the response.
+    """
+    if resp.data and resp.statistics is not None:
+        resp.data.transaction_id = resp.statistics.transaction_id or ""
+
+
+def report_getter_factory(config: ServiceConfiguration, resp_data_type: Type[R], allowed_clients: List[ClientType]):
+    """Create a function for getting a report with a transaction ID.
+
+    Arguments:
+    config (ServiceConfiguration):      The configuration for the report service.
+    resp_data_type (Type[R]):           The type of report data to return.
+    allowed_clients (List[ClientType]): The allowed client types for the report service.
+
+    Returns:    A function for getting a report with a transaction ID.
+    """
+
+    @mms_multi_endpoint(
+        name="ReportDownloadRequestTrnID",
+        service=config,
+        request_type=RequestType.REPORT,
+        allowed_clients=allowed_clients,
+        response_envelope_type=OutboundData,
+        response_data_type=resp_data_type,
+        serializer=Serializer(SchemaType.REPORT_RESPONSE, "OutboundData"),
+        for_report=True,
+    )
+    def get_report_with_transaction_id(
+        self: ClientProto,
+        request: ReportDownloadRequestTrnID,  # pylint: disable=unused-argument
+    ) -> List[resp_data_type]:  # type: ignore[valid-type]
+        """Request download of a report with a transaction ID.
+
+        This endpoint is accessible to any client, but may be rejected depending on the type of report being requested.
+
+        Arguments:
+        self (ClientProto):                     The client to use for making the request.
+        request (ReportDownloadRequestTrnID):   The request to download the report.
+
+        Returns:    The request to download the report.
+        """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        return ReportBase(  # type: ignore[return-value]
+            application_type=ApplicationType.MARKET_REPORT,
+            participant=self.participant,
+        )
+
+    return get_report_with_transaction_id
+
+
 class ReportClientMixin:  # pylint: disable=unused-argument
     """Report client for the MMS server."""
 
     # The configuration for the report service
-    config = ServiceConfiguration(Interface.MI, Serializer(SchemaType.REPORT, "MarketReport"))
+    config = ServiceConfiguration(
+        Interface.MI,
+        Serializer(SchemaType.REPORT, "MarketReport"),
+    )
+
+    @mms_endpoint(
+        name="ReportCreateRequest",
+        service=config,
+        request_type=RequestType.REPORT,
+        response_envelope_type=ReportBase,
+        response_data_type=NewReportResponse,
+        for_report=True,
+    )
+    def create_report(self: ClientProto, request: NewReportRequest) -> NewReportResponse:
+        """Request creation of a new report.
+
+        This endpoint is only accessible to BSPs.
+
+        Arguments:
+        request (NewReportRequest): The request to create the report.
+
+        Returns:    The request to create the report.
+        """
+        # If the client type is BSP, then we can't set the BSP name
+        if self.client_type == ClientType.BSP:
+            request.bsp_name = None
+
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        # Return the envelope and the callback function
+        return (
+            ReportBase(  # type: ignore[return-value]
+                application_type=ApplicationType.MARKET_REPORT,
+                participant=self.participant,
+            ),
+            attach_transaction_id,
+        )
+
+    @mms_endpoint(
+        name="ReportListRequest",
+        service=config,
+        request_type=RequestType.REPORT,
+        response_envelope_type=ReportBase,
+        response_data_type=ListReportResponse,
+        for_report=True,
+    )
+    def list_reports(self: ClientProto, request: ListReportRequest) -> ListReportResponse:
+        """Query the existing reports.
+
+        Arguments:
+        request (ListReportRequest): The request to query the reports.
+
+        Returns:    A list of reports that match the query.
+        """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        # Return the envelope and the callback function
+        return ReportBase(  # type: ignore[return-value]
+            application_type=ApplicationType.MARKET_REPORT,
+            participant=self.participant,
+        )
+
+    # Define the individual report getter functions here
+    list_bsp_resources = report_getter_factory(config, BSPResourceListItem, [ClientType.BSP])

mms_client/types/base.py

@@ -8,10 +8,12 @@ from typing import List
 from typing import Optional
 from typing import TypeVar
 
+from lxml.etree import _Element as Element
 from pydantic import PrivateAttr
 from pydantic_extra_types.pendulum_dt import DateTime
 from pydantic_xml import BaseXmlModel
 from pydantic_xml import attr
+from pydantic_xml import computed_element
 from pydantic_xml import element
 
 from mms_client.types.fields import transaction_id
@@ -34,17 +36,48 @@ class Message(BaseXmlModel):
     code: str = attr(default="", name="Code", min_length=2, max_length=50, pattern=r"^[a-zA-Z_0-9\-]*$")
 
 
-class Messages(BaseXmlModel, search_mode="unordered"):
+class Messages(BaseXmlModel, search_mode="unordered", arbitrary_types_allowed=True):
     """Represents a collection of messages returned with a payload."""
 
-    # A list of information messages returned with a payload
-    information: List[Message] = element(default=[], tag="Information", nillable=True)
+    # The raw information messages returned with a payload
+    information_raw: List[Element] = element(default=[], tag="Information", nillable=True, exclude=True)
 
-    # A list of warning messages returned with a payload
-    warnings: List[Message] = element(default=[], tag="Warning", nillable=True)
+    # The raw warning messages returned with a payload
+    warnings_raw: List[Element] = element(default=[], tag="Warning", nillable=True, exclude=True)
 
-    # A list of error messages returned with a payload
-    errors: List[Message] = element(default=[], tag="Error", nillable=True)
+    # The raw error messages returned with a payload
+    errors_raw: List[Element] = element(default=[], tag="Error", nillable=True, exclude=True)
+
+    @computed_element
+    def information(self) -> List[str]:
+        """Return the information messages."""
+        return self._parse_messages(self.information_raw)
+
+    @computed_element
+    def warnings(self) -> List[str]:
+        """Return the warning messages."""
+        return self._parse_messages(self.warnings_raw)
+
+    @computed_element
+    def errors(self) -> List[str]:
+        """Return the error messages."""
+        return self._parse_messages(self.errors_raw)
+
+    def _parse_messages(self, raw: List[Element]) -> List[str]:
+        """Parse the messages from the XML tree.
+
+        Arguments:
+        raw (List[Element]): The raw XML tree to parse.
+
+        Returns:    A list of message codes.
+        """
+        messages = []
+        for item in raw:
+            if message := item.attrib.get("Code"):
+                messages.append(message)
+            else:
+                messages.append(item.text or "")
+        return messages
 
 
 class ProcessingStatistics(BaseXmlModel):
@@ -87,7 +120,16 @@ class ResponseCommon(BaseXmlModel, search_mode="unordered"):
 
     # The status of the validation check done on the element. This field is not required for requests, and will be
     # populated in responses. For responses, the default value is "NOT_DONE".
-    validation: ValidationStatus = attr(default=ValidationStatus.NOT_DONE, name="Validation")
+    base_validation: Optional[ValidationStatus] = attr(default=None, name="Validation")
+
+    # The status of the validation check done on the element, specifically for reports. This field is not required for
+    # requests, and will be populated in responses. For responses, the default value is "NOT_DONE".
+    report_validation: Optional[ValidationStatus] = attr(default=None, name="ValidationStatus")
+
+    @property
+    def validation(self) -> ValidationStatus:
+        """Return the validation status of the element."""
+        return self.base_validation or self.report_validation or ValidationStatus.NOT_DONE
 
 
 class Payload(BaseXmlModel, search_mode="unordered"):
@@ -111,6 +153,7 @@ class SchemaType(Enum):
 
     MARKET = "mi-market.xsd"
     REPORT = "mi-report.xsd"
+    REPORT_RESPONSE = "mi-outbnd-reports.xsd"
     REGISTRATION = "mpr.xsd"
     OMI = "omi.xsd"
 
@@ -124,7 +167,7 @@ class BaseResponse(BaseXmlModel, Generic[E], tag="BaseResponse"):
 
     # The processing statistics returned with the payload. This will not be present in requests, and will be populated
     # in responses.
-    statistics: ProcessingStatistics = element(tag="ProcessingStatistics")
+    statistics: Optional[ProcessingStatistics] = element(default=None, tag="ProcessingStatistics")
 
     # The request payload, containing the request data
     _envelope: E = PrivateAttr()