onfido-python 2.10.0__py3-none-any.whl → 3.1.0__py3-none-any.whl

onfido/models/us_driving_licence_breakdown_personal.py

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+    Onfido API v3.6
+
+    The Onfido API (v3.6)
+
+    The version of the OpenAPI document: v3.6
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from onfido.models.us_driving_licence_breakdown_personal_breakdown import UsDrivingLicenceBreakdownPersonalBreakdown
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UsDrivingLicenceBreakdownPersonal(BaseModel):
+    """
+    Asserts whether the personal data provided matches a real driving license in the DMV driver's license database.
+    """ # noqa: E501
+    result: Optional[StrictStr] = None
+    breakdown: Optional[UsDrivingLicenceBreakdownPersonalBreakdown] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["result", "breakdown"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of UsDrivingLicenceBreakdownPersonal from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of breakdown
+        if self.breakdown:
+            _dict['breakdown'] = self.breakdown.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UsDrivingLicenceBreakdownPersonal from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "result": obj.get("result"),
+            "breakdown": UsDrivingLicenceBreakdownPersonalBreakdown.from_dict(obj["breakdown"]) if obj.get("breakdown") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

onfido/models/us_driving_licence_breakdown_personal_breakdown.py

@@ -0,0 +1,164 @@
+# coding: utf-8
+
+"""
+    Onfido API v3.6
+
+    The Onfido API (v3.6)
+
+    The version of the OpenAPI document: v3.6
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from onfido.models.document_breakdown_data_comparison_breakdown_issuing_country import DocumentBreakdownDataComparisonBreakdownIssuingCountry
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UsDrivingLicenceBreakdownPersonalBreakdown(BaseModel):
+    """
+    UsDrivingLicenceBreakdownPersonalBreakdown
+    """ # noqa: E501
+    first_name: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    name_suffix: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    height: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    weight: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    sex_code: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    eye_color: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    date_of_birth: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    last_name: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    middle_name: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    first_name_fuzzy: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    middle_name_fuzzy: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    last_name_fuzzy: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    middle_initial: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["first_name", "name_suffix", "height", "weight", "sex_code", "eye_color", "date_of_birth", "last_name", "middle_name", "first_name_fuzzy", "middle_name_fuzzy", "last_name_fuzzy", "middle_initial"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of UsDrivingLicenceBreakdownPersonalBreakdown from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of first_name
+        if self.first_name:
+            _dict['first_name'] = self.first_name.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of name_suffix
+        if self.name_suffix:
+            _dict['name_suffix'] = self.name_suffix.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of height
+        if self.height:
+            _dict['height'] = self.height.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of weight
+        if self.weight:
+            _dict['weight'] = self.weight.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of sex_code
+        if self.sex_code:
+            _dict['sex_code'] = self.sex_code.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of eye_color
+        if self.eye_color:
+            _dict['eye_color'] = self.eye_color.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of date_of_birth
+        if self.date_of_birth:
+            _dict['date_of_birth'] = self.date_of_birth.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of last_name
+        if self.last_name:
+            _dict['last_name'] = self.last_name.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of middle_name
+        if self.middle_name:
+            _dict['middle_name'] = self.middle_name.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of first_name_fuzzy
+        if self.first_name_fuzzy:
+            _dict['first_name_fuzzy'] = self.first_name_fuzzy.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of middle_name_fuzzy
+        if self.middle_name_fuzzy:
+            _dict['middle_name_fuzzy'] = self.middle_name_fuzzy.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of last_name_fuzzy
+        if self.last_name_fuzzy:
+            _dict['last_name_fuzzy'] = self.last_name_fuzzy.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of middle_initial
+        if self.middle_initial:
+            _dict['middle_initial'] = self.middle_initial.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UsDrivingLicenceBreakdownPersonalBreakdown from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "first_name": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["first_name"]) if obj.get("first_name") is not None else None,
+            "name_suffix": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["name_suffix"]) if obj.get("name_suffix") is not None else None,
+            "height": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["height"]) if obj.get("height") is not None else None,
+            "weight": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["weight"]) if obj.get("weight") is not None else None,
+            "sex_code": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["sex_code"]) if obj.get("sex_code") is not None else None,
+            "eye_color": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["eye_color"]) if obj.get("eye_color") is not None else None,
+            "date_of_birth": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["date_of_birth"]) if obj.get("date_of_birth") is not None else None,
+            "last_name": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["last_name"]) if obj.get("last_name") is not None else None,
+            "middle_name": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["middle_name"]) if obj.get("middle_name") is not None else None,
+            "first_name_fuzzy": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["first_name_fuzzy"]) if obj.get("first_name_fuzzy") is not None else None,
+            "middle_name_fuzzy": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["middle_name_fuzzy"]) if obj.get("middle_name_fuzzy") is not None else None,
+            "last_name_fuzzy": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["last_name_fuzzy"]) if obj.get("last_name_fuzzy") is not None else None,
+            "middle_initial": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["middle_initial"]) if obj.get("middle_initial") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

onfido/models/us_driving_licence_builder.py

@@ -0,0 +1,185 @@
+# coding: utf-8
+
+"""
+    Onfido API v3.6
+
+    The Onfido API (v3.6)
+
+    The version of the OpenAPI document: v3.6
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import date
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UsDrivingLicenceBuilder(BaseModel):
+    """
+    UsDrivingLicenceBuilder
+    """ # noqa: E501
+    id_number: StrictStr = Field(description="Driving licence ID number")
+    issue_state: Annotated[str, Field(strict=True)] = Field(description="Two letter code of issuing state (state-issued driving licenses only)")
+    address_line_1: Optional[StrictStr] = Field(default=None, description="Line 1 of the address")
+    address_line_2: Optional[StrictStr] = Field(default=None, description="Line 2 of the address")
+    city: Optional[StrictStr] = Field(default=None, description="The city of the owner's address")
+    date_of_birth: Optional[date] = Field(default=None, description="Date of birth in yyyy-mm-dd format")
+    document_category: Optional[StrictStr] = Field(default=None, description="Document category.")
+    expiration_date: Optional[date] = Field(default=None, description="Expiration date of the driving licence in yyyy-mm-dd format")
+    eye_color_code: Optional[StrictStr] = Field(default=None, description="Eye color code.")
+    first_name: Optional[StrictStr] = Field(default=None, description="The owner's first name")
+    gender: Optional[StrictStr] = None
+    issue_date: Optional[date] = Field(default=None, description="Issue date in yyyy-mm-dd format")
+    last_name: Optional[StrictStr] = Field(default=None, description="The owner's surname")
+    middle_name: Optional[StrictStr] = Field(default=None, description="The owner's middle name")
+    name_suffix: Optional[StrictStr] = Field(default=None, description="The owner's name suffix")
+    postal_code: Optional[StrictStr] = Field(default=None, description="The postcode or ZIP of the owner's address")
+    state: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="2-characters state code")
+    weight_measure: Optional[StrictInt] = Field(default=None, description="Weight in pounds")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["id_number", "issue_state", "address_line_1", "address_line_2", "city", "date_of_birth", "document_category", "expiration_date", "eye_color_code", "first_name", "gender", "issue_date", "last_name", "middle_name", "name_suffix", "postal_code", "state", "weight_measure"]
+
+    @field_validator('issue_state')
+    def issue_state_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[A-Z]{2}$", value):
+            raise ValueError(r"must validate the regular expression /^[A-Z]{2}$/")
+        return value
+
+    @field_validator('document_category')
+    def document_category_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['driver license', 'driver permit', 'id card']):
+            raise ValueError("must be one of enum values ('driver license', 'driver permit', 'id card')")
+        return value
+
+    @field_validator('eye_color_code')
+    def eye_color_code_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['BLK', 'BLU', 'BRO', 'DIC', 'GRY', 'GRN', 'HAZ', 'MAR', 'PNK']):
+            raise ValueError("must be one of enum values ('BLK', 'BLU', 'BRO', 'DIC', 'GRY', 'GRN', 'HAZ', 'MAR', 'PNK')")
+        return value
+
+    @field_validator('gender')
+    def gender_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['Male', 'Female']):
+            raise ValueError("must be one of enum values ('Male', 'Female')")
+        return value
+
+    @field_validator('state')
+    def state_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[A-Z]{2}$", value):
+            raise ValueError(r"must validate the regular expression /^[A-Z]{2}$/")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of UsDrivingLicenceBuilder from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * OpenAPI `readOnly` fields are excluded.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "gender",
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UsDrivingLicenceBuilder from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id_number": obj.get("id_number"),
+            "issue_state": obj.get("issue_state"),
+            "address_line_1": obj.get("address_line_1"),
+            "address_line_2": obj.get("address_line_2"),
+            "city": obj.get("city"),
+            "date_of_birth": obj.get("date_of_birth"),
+            "document_category": obj.get("document_category"),
+            "expiration_date": obj.get("expiration_date"),
+            "eye_color_code": obj.get("eye_color_code"),
+            "first_name": obj.get("first_name"),
+            "gender": obj.get("gender"),
+            "issue_date": obj.get("issue_date"),
+            "last_name": obj.get("last_name"),
+            "middle_name": obj.get("middle_name"),
+            "name_suffix": obj.get("name_suffix"),
+            "postal_code": obj.get("postal_code"),
+            "state": obj.get("state"),
+            "weight_measure": obj.get("weight_measure")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

onfido/models/us_driving_licence_report.py

@@ -0,0 +1,141 @@
+# coding: utf-8
+
+"""
+    Onfido API v3.6
+
+    The Onfido API (v3.6)
+
+    The version of the OpenAPI document: v3.6
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from onfido.models.document_properties import DocumentProperties
+from onfido.models.report_document import ReportDocument
+from onfido.models.report_name import ReportName
+from onfido.models.report_result import ReportResult
+from onfido.models.report_status import ReportStatus
+from onfido.models.report_sub_result import ReportSubResult
+from onfido.models.us_driving_licence_breakdown import UsDrivingLicenceBreakdown
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UsDrivingLicenceReport(BaseModel):
+    """
+    UsDrivingLicenceReport
+    """ # noqa: E501
+    id: StrictStr = Field(description="The unique identifier for the report. Read-only.")
+    created_at: Optional[datetime] = Field(default=None, description="The date and time at which the report was first initiated. Read-only.")
+    href: Optional[StrictStr] = Field(default=None, description="The API endpoint to retrieve the report. Read-only.")
+    status: Optional[ReportStatus] = None
+    result: Optional[ReportResult] = None
+    sub_result: Optional[ReportSubResult] = None
+    check_id: Optional[StrictStr] = Field(default=None, description="The ID of the check to which the report belongs. Read-only.")
+    documents: Optional[List[ReportDocument]] = Field(default=None, description="Array of objects with document ids that were used in the Onfido engine. [ONLY POPULATED FOR DOCUMENT AND FACIAL SIMILARITY REPORTS]")
+    name: ReportName
+    breakdown: Optional[UsDrivingLicenceBreakdown] = None
+    properties: Optional[DocumentProperties] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["id", "created_at", "href", "status", "result", "sub_result", "check_id", "documents", "name", "breakdown", "properties"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of UsDrivingLicenceReport from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in documents (list)
+        _items = []
+        if self.documents:
+            for _item in self.documents:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['documents'] = _items
+        # override the default output from pydantic by calling `to_dict()` of breakdown
+        if self.breakdown:
+            _dict['breakdown'] = self.breakdown.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of properties
+        if self.properties:
+            _dict['properties'] = self.properties.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UsDrivingLicenceReport from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "created_at": obj.get("created_at"),
+            "href": obj.get("href"),
+            "status": obj.get("status"),
+            "result": obj.get("result"),
+            "sub_result": obj.get("sub_result"),
+            "check_id": obj.get("check_id"),
+            "documents": [ReportDocument.from_dict(_item) for _item in obj["documents"]] if obj.get("documents") is not None else None,
+            "name": obj.get("name"),
+            "breakdown": UsDrivingLicenceBreakdown.from_dict(obj["breakdown"]) if obj.get("breakdown") is not None else None,
+            "properties": DocumentProperties.from_dict(obj["properties"]) if obj.get("properties") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+