onfido-python 5.0.0__py3-none-any.whl → 5.2.0__py3-none-any.whl

onfido/models/{device_intelligence_breakdown_breakdown_device.py → device_intelligence_breakdown_device.py}

@@ -19,15 +19,15 @@ import json
 
 from pydantic import BaseModel, ConfigDict
 from typing import Any, ClassVar, Dict, List, Optional
-from onfido.models.device_intelligence_breakdown_breakdown_device_breakdown import DeviceIntelligenceBreakdownBreakdownDeviceBreakdown
+from onfido.models.device_intelligence_breakdown_device_breakdown import DeviceIntelligenceBreakdownDeviceBreakdown
 from typing import Optional, Set
 from typing_extensions import Self
 
-class DeviceIntelligenceBreakdownBreakdownDevice(BaseModel):
+class DeviceIntelligenceBreakdownDevice(BaseModel):
     """
     Asserts whether the device used to upload the media is trustworthy, i.e. it is a real, physical device.
     """ # noqa: E501
-    breakdown: Optional[DeviceIntelligenceBreakdownBreakdownDeviceBreakdown] = None
+    breakdown: Optional[DeviceIntelligenceBreakdownDeviceBreakdown] = None
     additional_properties: Dict[str, Any] = {}
     __properties: ClassVar[List[str]] = ["breakdown"]
 
@@ -49,7 +49,7 @@ class DeviceIntelligenceBreakdownBreakdownDevice(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of DeviceIntelligenceBreakdownBreakdownDevice from a JSON string"""
+        """Create an instance of DeviceIntelligenceBreakdownDevice from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -84,7 +84,7 @@ class DeviceIntelligenceBreakdownBreakdownDevice(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of DeviceIntelligenceBreakdownBreakdownDevice from a dict"""
+        """Create an instance of DeviceIntelligenceBreakdownDevice from a dict"""
         if obj is None:
             return None
 
@@ -92,7 +92,7 @@ class DeviceIntelligenceBreakdownBreakdownDevice(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "breakdown": DeviceIntelligenceBreakdownBreakdownDeviceBreakdown.from_dict(obj["breakdown"]) if obj.get("breakdown") is not None else None
+            "breakdown": DeviceIntelligenceBreakdownDeviceBreakdown.from_dict(obj["breakdown"]) if obj.get("breakdown") is not None else None
         })
         # store additional fields in additional_properties
         for _key in obj.keys():

onfido/models/{device_intelligence_breakdown_breakdown_device_breakdown.py → device_intelligence_breakdown_device_breakdown.py}

@@ -23,9 +23,9 @@ from onfido.models.document_breakdown_data_comparison_breakdown_issuing_country
 from typing import Optional, Set
 from typing_extensions import Self
 
-class DeviceIntelligenceBreakdownBreakdownDeviceBreakdown(BaseModel):
+class DeviceIntelligenceBreakdownDeviceBreakdown(BaseModel):
     """
-    DeviceIntelligenceBreakdownBreakdownDeviceBreakdown
+    DeviceIntelligenceBreakdownDeviceBreakdown
     """ # noqa: E501
     application_authenticity: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
     device_integrity: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
@@ -51,7 +51,7 @@ class DeviceIntelligenceBreakdownBreakdownDeviceBreakdown(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of DeviceIntelligenceBreakdownBreakdownDeviceBreakdown from a JSON string"""
+        """Create an instance of DeviceIntelligenceBreakdownDeviceBreakdown from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -92,7 +92,7 @@ class DeviceIntelligenceBreakdownBreakdownDeviceBreakdown(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of DeviceIntelligenceBreakdownBreakdownDeviceBreakdown from a dict"""
+        """Create an instance of DeviceIntelligenceBreakdownDeviceBreakdown from a dict"""
         if obj is None:
             return None
 

onfido/models/device_intelligence_breakdown_properties_device.py

@@ -17,8 +17,8 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List, Optional
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -36,7 +36,7 @@ class DeviceIntelligenceBreakdownPropertiesDevice(BaseModel):
     randomized_device: Optional[StrictBool] = Field(default=None, description="Whether the device is providing false randomized device and network information.")
     fake_network_request: Optional[StrictBool] = Field(default=None, description="Whether device is using stolen security tokens to send the network information.")
     ip_reputation: Optional[StrictStr] = Field(default=None, description="Whether there is highly suspicious traffic related to the IP address. The risk depends on the overall ratio of clear checks on a given IP.")
-    device_fingerprint_reuse: Optional[StrictInt] = Field(default=None, description="The number of times the device was used to create a report for a new applicant. A value greater than 1 indicates potential device reuse.")
+    device_fingerprint_reuse: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The number of times the device was used to create a report for a new applicant. A value greater than 1 indicates potential device reuse.")
     single_device_used: Optional[StrictBool] = Field(default=None, description="Whether the document or biometric media were uploaded from a single device.")
     document_capture: Optional[StrictStr] = Field(default=None, description="Whether the document media were live captured from the device camera.")
     biometric_capture: Optional[StrictStr] = Field(default=None, description="Whether the biometric media were live captured from the device camera.")

onfido/models/device_intelligence_properties.py

@@ -0,0 +1,116 @@
+# 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.device_intelligence_breakdown_properties_device import DeviceIntelligenceBreakdownPropertiesDevice
+from onfido.models.device_intelligence_breakdown_properties_geolocation import DeviceIntelligenceBreakdownPropertiesGeolocation
+from onfido.models.device_intelligence_breakdown_properties_ip import DeviceIntelligenceBreakdownPropertiesIp
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DeviceIntelligenceProperties(BaseModel):
+    """
+    DeviceIntelligenceProperties
+    """ # noqa: E501
+    device: Optional[DeviceIntelligenceBreakdownPropertiesDevice] = None
+    ip: Optional[DeviceIntelligenceBreakdownPropertiesIp] = None
+    geolocation: Optional[DeviceIntelligenceBreakdownPropertiesGeolocation] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["device", "ip", "geolocation"]
+
+    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 DeviceIntelligenceProperties 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 device
+        if self.device:
+            _dict['device'] = self.device.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of ip
+        if self.ip:
+            _dict['ip'] = self.ip.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of geolocation
+        if self.geolocation:
+            _dict['geolocation'] = self.geolocation.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 DeviceIntelligenceProperties from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "device": DeviceIntelligenceBreakdownPropertiesDevice.from_dict(obj["device"]) if obj.get("device") is not None else None,
+            "ip": DeviceIntelligenceBreakdownPropertiesIp.from_dict(obj["ip"]) if obj.get("ip") is not None else None,
+            "geolocation": DeviceIntelligenceBreakdownPropertiesGeolocation.from_dict(obj["geolocation"]) if obj.get("geolocation") 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/device_intelligence_report.py

@@ -21,6 +21,7 @@ from datetime import datetime
 from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from onfido.models.device_intelligence_breakdown import DeviceIntelligenceBreakdown
+from onfido.models.device_intelligence_properties import DeviceIntelligenceProperties
 from onfido.models.report_name import ReportName
 from onfido.models.report_result import ReportResult
 from onfido.models.report_status import ReportStatus
@@ -41,8 +42,9 @@ class DeviceIntelligenceReport(BaseModel):
     check_id: Optional[StrictStr] = Field(default=None, description="The ID of the check to which the report belongs. Read-only.")
     name: ReportName
     breakdown: Optional[DeviceIntelligenceBreakdown] = None
+    properties: Optional[DeviceIntelligenceProperties] = None
     additional_properties: Dict[str, Any] = {}
-    __properties: ClassVar[List[str]] = ["id", "created_at", "href", "status", "result", "sub_result", "check_id", "name", "breakdown"]
+    __properties: ClassVar[List[str]] = ["id", "created_at", "href", "status", "result", "sub_result", "check_id", "name", "breakdown", "properties"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -88,6 +90,9 @@ class DeviceIntelligenceReport(BaseModel):
         # 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():
@@ -113,7 +118,8 @@ class DeviceIntelligenceReport(BaseModel):
             "sub_result": obj.get("sub_result"),
             "check_id": obj.get("check_id"),
             "name": obj.get("name"),
-            "breakdown": DeviceIntelligenceBreakdown.from_dict(obj["breakdown"]) if obj.get("breakdown") is not None else None
+            "breakdown": DeviceIntelligenceBreakdown.from_dict(obj["breakdown"]) if obj.get("breakdown") is not None else None,
+            "properties": DeviceIntelligenceProperties.from_dict(obj["properties"]) if obj.get("properties") is not None else None
         })
         # store additional fields in additional_properties
         for _key in obj.keys():

onfido/models/document_properties.py

@@ -24,7 +24,7 @@ from onfido.models.document_properties_address_lines import DocumentPropertiesAd
 from onfido.models.document_properties_barcode_inner import DocumentPropertiesBarcodeInner
 from onfido.models.document_properties_document_classification import DocumentPropertiesDocumentClassification
 from onfido.models.document_properties_document_numbers_inner import DocumentPropertiesDocumentNumbersInner
-from onfido.models.document_properties_driving_licence_information import DocumentPropertiesDrivingLicenceInformation
+from onfido.models.document_properties_driving_licence_information_item import DocumentPropertiesDrivingLicenceInformationItem
 from onfido.models.document_properties_extracted_data import DocumentPropertiesExtractedData
 from onfido.models.document_properties_nfc import DocumentPropertiesNfc
 from typing import Optional, Set
@@ -76,7 +76,7 @@ class DocumentProperties(BaseModel):
     address_lines: Optional[DocumentPropertiesAddressLines] = None
     barcode: Optional[List[DocumentPropertiesBarcodeInner]] = None
     nfc: Optional[DocumentPropertiesNfc] = None
-    driving_licence_information: Optional[DocumentPropertiesDrivingLicenceInformation] = None
+    driving_licence_information: Optional[List[DocumentPropertiesDrivingLicenceInformationItem]] = None
     document_classification: Optional[DocumentPropertiesDocumentClassification] = None
     extracted_data: Optional[DocumentPropertiesExtractedData] = None
     additional_properties: Dict[str, Any] = {}
@@ -173,9 +173,13 @@ class DocumentProperties(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of nfc
         if self.nfc:
             _dict['nfc'] = self.nfc.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of driving_licence_information
+        # override the default output from pydantic by calling `to_dict()` of each item in driving_licence_information (list)
+        _items = []
         if self.driving_licence_information:
-            _dict['driving_licence_information'] = self.driving_licence_information.to_dict()
+            for _item_driving_licence_information in self.driving_licence_information:
+                if _item_driving_licence_information:
+                    _items.append(_item_driving_licence_information.to_dict())
+            _dict['driving_licence_information'] = _items
         # override the default output from pydantic by calling `to_dict()` of document_classification
         if self.document_classification:
             _dict['document_classification'] = self.document_classification.to_dict()
@@ -241,7 +245,7 @@ class DocumentProperties(BaseModel):
             "address_lines": DocumentPropertiesAddressLines.from_dict(obj["address_lines"]) if obj.get("address_lines") is not None else None,
             "barcode": [DocumentPropertiesBarcodeInner.from_dict(_item) for _item in obj["barcode"]] if obj.get("barcode") is not None else None,
             "nfc": DocumentPropertiesNfc.from_dict(obj["nfc"]) if obj.get("nfc") is not None else None,
-            "driving_licence_information": DocumentPropertiesDrivingLicenceInformation.from_dict(obj["driving_licence_information"]) if obj.get("driving_licence_information") is not None else None,
+            "driving_licence_information": [DocumentPropertiesDrivingLicenceInformationItem.from_dict(_item) for _item in obj["driving_licence_information"]] if obj.get("driving_licence_information") is not None else None,
             "document_classification": DocumentPropertiesDocumentClassification.from_dict(obj["document_classification"]) if obj.get("document_classification") is not None else None,
             "extracted_data": DocumentPropertiesExtractedData.from_dict(obj["extracted_data"]) if obj.get("extracted_data") is not None else None
         })

onfido/models/{document_properties_driving_licence_information.py → document_properties_driving_licence_information_item.py}

@@ -23,9 +23,9 @@ from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class DocumentPropertiesDrivingLicenceInformation(BaseModel):
+class DocumentPropertiesDrivingLicenceInformationItem(BaseModel):
     """
-    DocumentPropertiesDrivingLicenceInformation
+    DocumentPropertiesDrivingLicenceInformationItem
     """ # noqa: E501
     category: Optional[StrictStr] = None
     obtainment_date: Optional[date] = None
@@ -52,7 +52,7 @@ class DocumentPropertiesDrivingLicenceInformation(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of DocumentPropertiesDrivingLicenceInformation from a JSON string"""
+        """Create an instance of DocumentPropertiesDrivingLicenceInformationItem from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -84,7 +84,7 @@ class DocumentPropertiesDrivingLicenceInformation(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of DocumentPropertiesDrivingLicenceInformation from a dict"""
+        """Create an instance of DocumentPropertiesDrivingLicenceInformationItem from a dict"""
         if obj is None:
             return None
 

onfido/models/document_with_driver_verification_report_all_of_properties.py

@@ -24,7 +24,7 @@ from onfido.models.document_properties_address_lines import DocumentPropertiesAd
 from onfido.models.document_properties_barcode_inner import DocumentPropertiesBarcodeInner
 from onfido.models.document_properties_document_classification import DocumentPropertiesDocumentClassification
 from onfido.models.document_properties_document_numbers_inner import DocumentPropertiesDocumentNumbersInner
-from onfido.models.document_properties_driving_licence_information import DocumentPropertiesDrivingLicenceInformation
+from onfido.models.document_properties_driving_licence_information_item import DocumentPropertiesDrivingLicenceInformationItem
 from onfido.models.document_properties_extracted_data import DocumentPropertiesExtractedData
 from onfido.models.document_properties_nfc import DocumentPropertiesNfc
 from onfido.models.document_with_driver_verification_report_all_of_properties_all_of_passenger_vehicle import DocumentWithDriverVerificationReportAllOfPropertiesAllOfPassengerVehicle
@@ -78,7 +78,7 @@ class DocumentWithDriverVerificationReportAllOfProperties(BaseModel):
     address_lines: Optional[DocumentPropertiesAddressLines] = None
     barcode: Optional[List[DocumentPropertiesBarcodeInner]] = None
     nfc: Optional[DocumentPropertiesNfc] = None
-    driving_licence_information: Optional[DocumentPropertiesDrivingLicenceInformation] = None
+    driving_licence_information: Optional[List[DocumentPropertiesDrivingLicenceInformationItem]] = None
     document_classification: Optional[DocumentPropertiesDocumentClassification] = None
     extracted_data: Optional[DocumentPropertiesExtractedData] = None
     drivers_licence: Optional[StrictBool] = Field(default=None, description="True for **non-restricted** driving licences")
@@ -181,9 +181,13 @@ class DocumentWithDriverVerificationReportAllOfProperties(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of nfc
         if self.nfc:
             _dict['nfc'] = self.nfc.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of driving_licence_information
+        # override the default output from pydantic by calling `to_dict()` of each item in driving_licence_information (list)
+        _items = []
         if self.driving_licence_information:
-            _dict['driving_licence_information'] = self.driving_licence_information.to_dict()
+            for _item_driving_licence_information in self.driving_licence_information:
+                if _item_driving_licence_information:
+                    _items.append(_item_driving_licence_information.to_dict())
+            _dict['driving_licence_information'] = _items
         # override the default output from pydantic by calling `to_dict()` of document_classification
         if self.document_classification:
             _dict['document_classification'] = self.document_classification.to_dict()
@@ -259,7 +263,7 @@ class DocumentWithDriverVerificationReportAllOfProperties(BaseModel):
             "address_lines": DocumentPropertiesAddressLines.from_dict(obj["address_lines"]) if obj.get("address_lines") is not None else None,
             "barcode": [DocumentPropertiesBarcodeInner.from_dict(_item) for _item in obj["barcode"]] if obj.get("barcode") is not None else None,
             "nfc": DocumentPropertiesNfc.from_dict(obj["nfc"]) if obj.get("nfc") is not None else None,
-            "driving_licence_information": DocumentPropertiesDrivingLicenceInformation.from_dict(obj["driving_licence_information"]) if obj.get("driving_licence_information") is not None else None,
+            "driving_licence_information": [DocumentPropertiesDrivingLicenceInformationItem.from_dict(_item) for _item in obj["driving_licence_information"]] if obj.get("driving_licence_information") is not None else None,
             "document_classification": DocumentPropertiesDocumentClassification.from_dict(obj["document_classification"]) if obj.get("document_classification") is not None else None,
             "extracted_data": DocumentPropertiesExtractedData.from_dict(obj["extracted_data"]) if obj.get("extracted_data") is not None else None,
             "drivers_licence": obj.get("drivers_licence"),

onfido/models/report_configuration.py

@@ -0,0 +1,119 @@
+# 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.report_configuration_facial_similarity import ReportConfigurationFacialSimilarity
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReportConfiguration(BaseModel):
+    """
+    Defines configuration options for facial similarity checks used to distinguish between onboarding and reverification scenarios. 
+    """ # noqa: E501
+    facial_similarity_photo: Optional[ReportConfigurationFacialSimilarity] = None
+    facial_similarity_photo_fully_auto: Optional[ReportConfigurationFacialSimilarity] = None
+    facial_similarity_video: Optional[ReportConfigurationFacialSimilarity] = None
+    facial_similarity_motion: Optional[ReportConfigurationFacialSimilarity] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["facial_similarity_photo", "facial_similarity_photo_fully_auto", "facial_similarity_video", "facial_similarity_motion"]
+
+    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 ReportConfiguration 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 facial_similarity_photo
+        if self.facial_similarity_photo:
+            _dict['facial_similarity_photo'] = self.facial_similarity_photo.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of facial_similarity_photo_fully_auto
+        if self.facial_similarity_photo_fully_auto:
+            _dict['facial_similarity_photo_fully_auto'] = self.facial_similarity_photo_fully_auto.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of facial_similarity_video
+        if self.facial_similarity_video:
+            _dict['facial_similarity_video'] = self.facial_similarity_video.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of facial_similarity_motion
+        if self.facial_similarity_motion:
+            _dict['facial_similarity_motion'] = self.facial_similarity_motion.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 ReportConfiguration from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "facial_similarity_photo": ReportConfigurationFacialSimilarity.from_dict(obj["facial_similarity_photo"]) if obj.get("facial_similarity_photo") is not None else None,
+            "facial_similarity_photo_fully_auto": ReportConfigurationFacialSimilarity.from_dict(obj["facial_similarity_photo_fully_auto"]) if obj.get("facial_similarity_photo_fully_auto") is not None else None,
+            "facial_similarity_video": ReportConfigurationFacialSimilarity.from_dict(obj["facial_similarity_video"]) if obj.get("facial_similarity_video") is not None else None,
+            "facial_similarity_motion": ReportConfigurationFacialSimilarity.from_dict(obj["facial_similarity_motion"]) if obj.get("facial_similarity_motion") 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/report_configuration_facial_similarity.py

@@ -0,0 +1,110 @@
+# 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, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReportConfigurationFacialSimilarity(BaseModel):
+    """
+    ReportConfigurationFacialSimilarity
+    """ # noqa: E501
+    use_case: Optional[StrictStr] = Field(default=None, description="You should set it to \"reverification\" on a post-onboarding scenario (e.g. ongoing authentication). ")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["use_case"]
+
+    @field_validator('use_case')
+    def use_case_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['onboarding', 'reverification', 'unknown_default_open_api']):
+            raise ValueError("must be one of enum values ('onboarding', 'reverification', 'unknown_default_open_api')")
+        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 ReportConfigurationFacialSimilarity 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,
+        )
+        # 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 ReportConfigurationFacialSimilarity from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "use_case": obj.get("use_case")
+        })
+        # 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/webhook.py

@@ -31,12 +31,17 @@ class Webhook(BaseModel):
     events: Optional[List[WebhookEventType]] = Field(default=None, description="The events that will be published to the webhook. If the events parameter is omitted all the events will be subscribed. ")
     environments: Optional[List[StrictStr]] = Field(default=None, description="The environments from which the webhook will receive events. Allowed values are “sandbox” and “live”. If the environments parameter is omitted the webhook will receive events from both environments. ")
     payload_version: Optional[StrictInt] = Field(default=None, description="Webhook version used to control the payload object when sending webhooks.")
+    oauth_enabled: Optional[StrictBool] = Field(default=None, description="Determines if the webhook will fetch OAuth access tokens to send in the Authorization header.")
+    oauth_server_url: Optional[StrictStr] = Field(default=None, description="The url to fetch the OAuth access token using client credentials grant.")
+    oauth_server_client_id: Optional[StrictStr] = Field(default=None, description="The client id to authenticate the client credentials grant.")
+    oauth_server_client_secret: Optional[StrictStr] = Field(default=None, description="The client secret to authenticate the client credentials grant.")
+    oauth_server_scope: Optional[StrictStr] = Field(default=None, description="The scopes to be sent when requesting the access token.")
     id: StrictStr = Field(description="The unique identifier of the webhook.")
     url: Optional[StrictStr] = Field(default=None, description="The url that will listen to notifications (must be https).")
     token: Optional[StrictStr] = Field(default=None, description="Webhook secret token used to sign the webhook's payload.")
     href: Optional[StrictStr] = Field(default=None, description="The API endpoint to retrieve the webhook.")
     additional_properties: Dict[str, Any] = {}
-    __properties: ClassVar[List[str]] = ["enabled", "events", "environments", "payload_version", "id", "url", "token", "href"]
+    __properties: ClassVar[List[str]] = ["enabled", "events", "environments", "payload_version", "oauth_enabled", "oauth_server_url", "oauth_server_client_id", "oauth_server_client_secret", "oauth_server_scope", "id", "url", "token", "href"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -100,6 +105,11 @@ class Webhook(BaseModel):
             "events": obj.get("events"),
             "environments": obj.get("environments"),
             "payload_version": obj.get("payload_version"),
+            "oauth_enabled": obj.get("oauth_enabled"),
+            "oauth_server_url": obj.get("oauth_server_url"),
+            "oauth_server_client_id": obj.get("oauth_server_client_id"),
+            "oauth_server_client_secret": obj.get("oauth_server_client_secret"),
+            "oauth_server_scope": obj.get("oauth_server_scope"),
             "id": obj.get("id"),
             "url": obj.get("url"),
             "token": obj.get("token"),