onfido-python 3.3.0__py3-none-any.whl → 3.5.0__py3-none-any.whl

onfido/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "3.3.0"
+__version__ = "3.5.0"
 
 # import apis into sdk package
 from onfido.api.default_api import DefaultApi
@@ -271,6 +271,14 @@ from onfido.models.watchlist_aml_properties import WatchlistAmlProperties
 from onfido.models.watchlist_aml_report import WatchlistAmlReport
 from onfido.models.watchlist_enhanced_breakdown import WatchlistEnhancedBreakdown
 from onfido.models.watchlist_enhanced_properties import WatchlistEnhancedProperties
+from onfido.models.watchlist_enhanced_properties_records_inner import WatchlistEnhancedPropertiesRecordsInner
+from onfido.models.watchlist_enhanced_properties_records_inner_address_inner import WatchlistEnhancedPropertiesRecordsInnerAddressInner
+from onfido.models.watchlist_enhanced_properties_records_inner_alias_inner import WatchlistEnhancedPropertiesRecordsInnerAliasInner
+from onfido.models.watchlist_enhanced_properties_records_inner_associate_inner import WatchlistEnhancedPropertiesRecordsInnerAssociateInner
+from onfido.models.watchlist_enhanced_properties_records_inner_attribute_inner import WatchlistEnhancedPropertiesRecordsInnerAttributeInner
+from onfido.models.watchlist_enhanced_properties_records_inner_event_inner import WatchlistEnhancedPropertiesRecordsInnerEventInner
+from onfido.models.watchlist_enhanced_properties_records_inner_event_inner_source import WatchlistEnhancedPropertiesRecordsInnerEventInnerSource
+from onfido.models.watchlist_enhanced_properties_records_inner_source_inner import WatchlistEnhancedPropertiesRecordsInnerSourceInner
 from onfido.models.watchlist_enhanced_report import WatchlistEnhancedReport
 from onfido.models.watchlist_monitor import WatchlistMonitor
 from onfido.models.watchlist_monitor_builder import WatchlistMonitorBuilder

onfido/api_client.py

@@ -88,7 +88,7 @@ class ApiClient:
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'onfido-python/3.3.0'
+        self.user_agent = 'onfido-python/3.5.0'
         self.client_side_validation = configuration.client_side_validation
 
     def __enter__(self):

onfido/configuration.py

@@ -383,7 +383,7 @@ conf = onfido.Configuration(
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: v3.6\n"\
-               "SDK Package Version: 3.3.0".\
+               "SDK Package Version: 3.5.0".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self):

onfido/models/__init__.py

@@ -254,6 +254,14 @@ from onfido.models.watchlist_aml_properties import WatchlistAmlProperties
 from onfido.models.watchlist_aml_report import WatchlistAmlReport
 from onfido.models.watchlist_enhanced_breakdown import WatchlistEnhancedBreakdown
 from onfido.models.watchlist_enhanced_properties import WatchlistEnhancedProperties
+from onfido.models.watchlist_enhanced_properties_records_inner import WatchlistEnhancedPropertiesRecordsInner
+from onfido.models.watchlist_enhanced_properties_records_inner_address_inner import WatchlistEnhancedPropertiesRecordsInnerAddressInner
+from onfido.models.watchlist_enhanced_properties_records_inner_alias_inner import WatchlistEnhancedPropertiesRecordsInnerAliasInner
+from onfido.models.watchlist_enhanced_properties_records_inner_associate_inner import WatchlistEnhancedPropertiesRecordsInnerAssociateInner
+from onfido.models.watchlist_enhanced_properties_records_inner_attribute_inner import WatchlistEnhancedPropertiesRecordsInnerAttributeInner
+from onfido.models.watchlist_enhanced_properties_records_inner_event_inner import WatchlistEnhancedPropertiesRecordsInnerEventInner
+from onfido.models.watchlist_enhanced_properties_records_inner_event_inner_source import WatchlistEnhancedPropertiesRecordsInnerEventInnerSource
+from onfido.models.watchlist_enhanced_properties_records_inner_source_inner import WatchlistEnhancedPropertiesRecordsInnerSourceInner
 from onfido.models.watchlist_enhanced_report import WatchlistEnhancedReport
 from onfido.models.watchlist_monitor import WatchlistMonitor
 from onfido.models.watchlist_monitor_builder import WatchlistMonitorBuilder

onfido/models/watchlist_enhanced_properties.py

@@ -17,8 +17,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from pydantic import BaseModel, ConfigDict, Field
 from typing import Any, ClassVar, Dict, List, Optional
+from onfido.models.watchlist_enhanced_properties_records_inner import WatchlistEnhancedPropertiesRecordsInner
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -26,7 +27,7 @@ class WatchlistEnhancedProperties(BaseModel):
     """
     WatchlistEnhancedProperties
     """ # noqa: E501
-    records: Optional[List[StrictStr]] = Field(default=None, description="Returns any matches including, but not limited to, name and date of birth of match, aliases and associates, and relevant events and sources.")
+    records: Optional[List[WatchlistEnhancedPropertiesRecordsInner]] = Field(default=None, description="Returns any matches including, but not limited to, name and date of birth of match, aliases and associates, and relevant events and sources.")
     additional_properties: Dict[str, Any] = {}
     __properties: ClassVar[List[str]] = ["records"]
 
@@ -71,6 +72,13 @@ class WatchlistEnhancedProperties(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of each item in records (list)
+        _items = []
+        if self.records:
+            for _item in self.records:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['records'] = _items
         # 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():
@@ -88,7 +96,7 @@ class WatchlistEnhancedProperties(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "records": obj.get("records")
+            "records": [WatchlistEnhancedPropertiesRecordsInner.from_dict(_item) for _item in obj["records"]] if obj.get("records") is not None else None
         })
         # store additional fields in additional_properties
         for _key in obj.keys():

onfido/models/watchlist_enhanced_properties_records_inner.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, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from onfido.models.watchlist_enhanced_properties_records_inner_address_inner import WatchlistEnhancedPropertiesRecordsInnerAddressInner
+from onfido.models.watchlist_enhanced_properties_records_inner_alias_inner import WatchlistEnhancedPropertiesRecordsInnerAliasInner
+from onfido.models.watchlist_enhanced_properties_records_inner_associate_inner import WatchlistEnhancedPropertiesRecordsInnerAssociateInner
+from onfido.models.watchlist_enhanced_properties_records_inner_attribute_inner import WatchlistEnhancedPropertiesRecordsInnerAttributeInner
+from onfido.models.watchlist_enhanced_properties_records_inner_event_inner import WatchlistEnhancedPropertiesRecordsInnerEventInner
+from onfido.models.watchlist_enhanced_properties_records_inner_source_inner import WatchlistEnhancedPropertiesRecordsInnerSourceInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class WatchlistEnhancedPropertiesRecordsInner(BaseModel):
+    """
+    WatchlistEnhancedPropertiesRecordsInner
+    """ # noqa: E501
+    address: Optional[List[WatchlistEnhancedPropertiesRecordsInnerAddressInner]] = Field(default=None, description="All addresses on file.")
+    alias: Optional[List[WatchlistEnhancedPropertiesRecordsInnerAliasInner]] = Field(default=None, description="Any names that the person is also known as.")
+    associate: Optional[List[WatchlistEnhancedPropertiesRecordsInnerAssociateInner]] = Field(default=None, description="Any linked persons, for example family relatives or business partners.")
+    attribute: Optional[List[WatchlistEnhancedPropertiesRecordsInnerAttributeInner]] = Field(default=None, description="Information about the person, for example hair color or nationality.")
+    date_of_birth: Optional[List[StrictStr]] = Field(default=None, description="All the date of births on file.")
+    event: Optional[List[WatchlistEnhancedPropertiesRecordsInnerEventInner]] = Field(default=None, description="Information about events that have occurred to the person, for example deportation or arrest.")
+    full_name: Optional[StrictStr] = Field(default=None, description="The name on file")
+    position: Optional[List[StrictStr]] = Field(default=None, description="The role, country and date of each position.")
+    source: Optional[List[WatchlistEnhancedPropertiesRecordsInnerSourceInner]] = Field(default=None, description="Details about where the information was obtained.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["address", "alias", "associate", "attribute", "date_of_birth", "event", "full_name", "position", "source"]
+
+    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 WatchlistEnhancedPropertiesRecordsInner 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 address (list)
+        _items = []
+        if self.address:
+            for _item in self.address:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['address'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in alias (list)
+        _items = []
+        if self.alias:
+            for _item in self.alias:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['alias'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in associate (list)
+        _items = []
+        if self.associate:
+            for _item in self.associate:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['associate'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in attribute (list)
+        _items = []
+        if self.attribute:
+            for _item in self.attribute:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['attribute'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in event (list)
+        _items = []
+        if self.event:
+            for _item in self.event:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['event'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in source (list)
+        _items = []
+        if self.source:
+            for _item in self.source:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['source'] = _items
+        # 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 WatchlistEnhancedPropertiesRecordsInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "address": [WatchlistEnhancedPropertiesRecordsInnerAddressInner.from_dict(_item) for _item in obj["address"]] if obj.get("address") is not None else None,
+            "alias": [WatchlistEnhancedPropertiesRecordsInnerAliasInner.from_dict(_item) for _item in obj["alias"]] if obj.get("alias") is not None else None,
+            "associate": [WatchlistEnhancedPropertiesRecordsInnerAssociateInner.from_dict(_item) for _item in obj["associate"]] if obj.get("associate") is not None else None,
+            "attribute": [WatchlistEnhancedPropertiesRecordsInnerAttributeInner.from_dict(_item) for _item in obj["attribute"]] if obj.get("attribute") is not None else None,
+            "date_of_birth": obj.get("date_of_birth"),
+            "event": [WatchlistEnhancedPropertiesRecordsInnerEventInner.from_dict(_item) for _item in obj["event"]] if obj.get("event") is not None else None,
+            "full_name": obj.get("full_name"),
+            "position": obj.get("position"),
+            "source": [WatchlistEnhancedPropertiesRecordsInnerSourceInner.from_dict(_item) for _item in obj["source"]] if obj.get("source") 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/watchlist_enhanced_properties_records_inner_address_inner.py

@@ -0,0 +1,111 @@
+# 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.country_codes import CountryCodes
+from typing import Optional, Set
+from typing_extensions import Self
+
+class WatchlistEnhancedPropertiesRecordsInnerAddressInner(BaseModel):
+    """
+    WatchlistEnhancedPropertiesRecordsInnerAddressInner
+    """ # noqa: E501
+    address_line1: Optional[StrictStr] = None
+    country: Optional[CountryCodes] = None
+    postal_code: Optional[StrictStr] = None
+    state_province: Optional[StrictStr] = None
+    town: Optional[StrictStr] = None
+    locator_type: Optional[StrictStr] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["address_line1", "country", "postal_code", "state_province", "town", "locator_type"]
+
+    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 WatchlistEnhancedPropertiesRecordsInnerAddressInner 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 WatchlistEnhancedPropertiesRecordsInnerAddressInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "address_line1": obj.get("address_line1"),
+            "country": obj.get("country"),
+            "postal_code": obj.get("postal_code"),
+            "state_province": obj.get("state_province"),
+            "town": obj.get("town"),
+            "locator_type": obj.get("locator_type")
+        })
+        # 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/watchlist_enhanced_properties_records_inner_alias_inner.py

@@ -0,0 +1,102 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+
+class WatchlistEnhancedPropertiesRecordsInnerAliasInner(BaseModel):
+    """
+    WatchlistEnhancedPropertiesRecordsInnerAliasInner
+    """ # noqa: E501
+    alias_name: Optional[StrictStr] = None
+    alias_type: Optional[StrictStr] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["alias_name", "alias_type"]
+
+    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 WatchlistEnhancedPropertiesRecordsInnerAliasInner 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 WatchlistEnhancedPropertiesRecordsInnerAliasInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "alias_name": obj.get("alias_name"),
+            "alias_type": obj.get("alias_type")
+        })
+        # 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/watchlist_enhanced_properties_records_inner_associate_inner.py

@@ -0,0 +1,104 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+
+class WatchlistEnhancedPropertiesRecordsInnerAssociateInner(BaseModel):
+    """
+    WatchlistEnhancedPropertiesRecordsInnerAssociateInner
+    """ # noqa: E501
+    entity_name: Optional[StrictStr] = None
+    relationship_direction: Optional[StrictStr] = None
+    relationship_type: Optional[StrictStr] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["entity_name", "relationship_direction", "relationship_type"]
+
+    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 WatchlistEnhancedPropertiesRecordsInnerAssociateInner 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 WatchlistEnhancedPropertiesRecordsInnerAssociateInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "entity_name": obj.get("entity_name"),
+            "relationship_direction": obj.get("relationship_direction"),
+            "relationship_type": obj.get("relationship_type")
+        })
+        # 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/watchlist_enhanced_properties_records_inner_attribute_inner.py

@@ -0,0 +1,102 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+
+class WatchlistEnhancedPropertiesRecordsInnerAttributeInner(BaseModel):
+    """
+    WatchlistEnhancedPropertiesRecordsInnerAttributeInner
+    """ # noqa: E501
+    attribute_type: Optional[StrictStr] = None
+    attribute_value: Optional[StrictStr] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["attribute_type", "attribute_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 WatchlistEnhancedPropertiesRecordsInnerAttributeInner 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 WatchlistEnhancedPropertiesRecordsInnerAttributeInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "attribute_type": obj.get("attribute_type"),
+            "attribute_value": obj.get("attribute_value")
+        })
+        # 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/watchlist_enhanced_properties_records_inner_event_inner.py

@@ -0,0 +1,113 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from onfido.models.watchlist_enhanced_properties_records_inner_event_inner_source import WatchlistEnhancedPropertiesRecordsInnerEventInnerSource
+from typing import Optional, Set
+from typing_extensions import Self
+
+class WatchlistEnhancedPropertiesRecordsInnerEventInner(BaseModel):
+    """
+    WatchlistEnhancedPropertiesRecordsInnerEventInner
+    """ # noqa: E501
+    category: Optional[StrictStr] = None
+    event_date: Optional[date] = None
+    event_description: Optional[StrictStr] = None
+    source: Optional[WatchlistEnhancedPropertiesRecordsInnerEventInnerSource] = None
+    sub_category: Optional[StrictStr] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["category", "event_date", "event_description", "source", "sub_category"]
+
+    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 WatchlistEnhancedPropertiesRecordsInnerEventInner 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 source
+        if self.source:
+            _dict['source'] = self.source.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 WatchlistEnhancedPropertiesRecordsInnerEventInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "category": obj.get("category"),
+            "event_date": obj.get("event_date"),
+            "event_description": obj.get("event_description"),
+            "source": WatchlistEnhancedPropertiesRecordsInnerEventInnerSource.from_dict(obj["source"]) if obj.get("source") is not None else None,
+            "sub_category": obj.get("sub_category")
+        })
+        # 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/watchlist_enhanced_properties_records_inner_event_inner_source.py

@@ -0,0 +1,107 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class WatchlistEnhancedPropertiesRecordsInnerEventInnerSource(BaseModel):
+    """
+    WatchlistEnhancedPropertiesRecordsInnerEventInnerSource
+    """ # noqa: E501
+    source_date: Optional[date] = None
+    source_format: Optional[StrictStr] = None
+    source_name: Optional[StrictStr] = None
+    source_url: Optional[StrictStr] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["source_date", "source_format", "source_name", "source_url"]
+
+    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 WatchlistEnhancedPropertiesRecordsInnerEventInnerSource 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 WatchlistEnhancedPropertiesRecordsInnerEventInnerSource from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "source_date": obj.get("source_date"),
+            "source_format": obj.get("source_format"),
+            "source_name": obj.get("source_name"),
+            "source_url": obj.get("source_url")
+        })
+        # 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/watchlist_enhanced_properties_records_inner_source_inner.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 typing import Optional, Set
+from typing_extensions import Self
+
+class WatchlistEnhancedPropertiesRecordsInnerSourceInner(BaseModel):
+    """
+    WatchlistEnhancedPropertiesRecordsInnerSourceInner
+    """ # noqa: E501
+    source_headline: Optional[StrictStr] = None
+    source_name: Optional[StrictStr] = None
+    source_url: Optional[StrictStr] = None
+    source_format: Optional[StrictStr] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["source_headline", "source_name", "source_url", "source_format"]
+
+    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 WatchlistEnhancedPropertiesRecordsInnerSourceInner 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 WatchlistEnhancedPropertiesRecordsInnerSourceInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "source_headline": obj.get("source_headline"),
+            "source_name": obj.get("source_name"),
+            "source_url": obj.get("source_url"),
+            "source_format": obj.get("source_format")
+        })
+        # 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/workflow_run.py

@@ -33,6 +33,7 @@ class WorkflowRun(BaseModel):
     applicant_id: StrictStr = Field(description="The unique identifier for the Applicant.")
     workflow_id: StrictStr = Field(description="The unique identifier for the Workflow.")
     tags: Optional[Annotated[List[Annotated[str, Field(min_length=1, strict=True, max_length=128)]], Field(max_length=30)]] = Field(default=None, description="Tags or labels assigned to the workflow run.")
+    customer_user_id: Optional[Annotated[str, Field(strict=True, max_length=256)]] = Field(default=None, description="Customer-provided user identifier.")
     link: Optional[WorkflowRunSharedLink] = None
     created_at: Optional[datetime] = Field(default=None, description="The date and time when the Workflow Run was created.")
     updated_at: Optional[datetime] = Field(default=None, description="The date and time when the Workflow Run was last updated.")
@@ -43,8 +44,9 @@ class WorkflowRun(BaseModel):
     output: Optional[Dict[str, Any]] = Field(default=None, description="Output object contains all of the properties configured on the Workflow version.")
     reasons: Optional[List[StrictStr]] = Field(default=None, description="The reasons the Workflow Run outcome was reached. Configurable when creating the Workflow version.")
     error: Optional[WorkflowRunResponseError] = None
+    sdk_token: Optional[StrictStr] = Field(default=None, description="Client token to use when loading this workflow run in the Onfido SDK.")
     additional_properties: Dict[str, Any] = {}
-    __properties: ClassVar[List[str]] = ["applicant_id", "workflow_id", "tags", "link", "created_at", "updated_at", "id", "workflow_version_id", "dashboard_url", "status", "output", "reasons", "error"]
+    __properties: ClassVar[List[str]] = ["applicant_id", "workflow_id", "tags", "customer_user_id", "link", "created_at", "updated_at", "id", "workflow_version_id", "dashboard_url", "status", "output", "reasons", "error", "sdk_token"]
 
     @field_validator('status')
     def status_validate_enum(cls, value):
@@ -113,6 +115,11 @@ class WorkflowRun(BaseModel):
         if self.tags is None and "tags" in self.model_fields_set:
             _dict['tags'] = None
 
+        # set to None if sdk_token (nullable) is None
+        # and model_fields_set contains the field
+        if self.sdk_token is None and "sdk_token" in self.model_fields_set:
+            _dict['sdk_token'] = None
+
         return _dict
 
     @classmethod
@@ -128,6 +135,7 @@ class WorkflowRun(BaseModel):
             "applicant_id": obj.get("applicant_id"),
             "workflow_id": obj.get("workflow_id"),
             "tags": obj.get("tags"),
+            "customer_user_id": obj.get("customer_user_id"),
             "link": WorkflowRunSharedLink.from_dict(obj["link"]) if obj.get("link") is not None else None,
             "created_at": obj.get("created_at"),
             "updated_at": obj.get("updated_at"),
@@ -137,7 +145,8 @@ class WorkflowRun(BaseModel):
             "status": obj.get("status"),
             "output": obj.get("output"),
             "reasons": obj.get("reasons"),
-            "error": WorkflowRunResponseError.from_dict(obj["error"]) if obj.get("error") is not None else None
+            "error": WorkflowRunResponseError.from_dict(obj["error"]) if obj.get("error") is not None else None,
+            "sdk_token": obj.get("sdk_token")
         })
         # store additional fields in additional_properties
         for _key in obj.keys():

onfido/models/workflow_run_builder.py

@@ -32,12 +32,13 @@ class WorkflowRunBuilder(BaseModel):
     applicant_id: StrictStr = Field(description="The unique identifier for the Applicant.")
     workflow_id: StrictStr = Field(description="The unique identifier for the Workflow.")
     tags: Optional[Annotated[List[Annotated[str, Field(min_length=1, strict=True, max_length=128)]], Field(max_length=30)]] = Field(default=None, description="Tags or labels assigned to the workflow run.")
+    customer_user_id: Optional[Annotated[str, Field(strict=True, max_length=256)]] = Field(default=None, description="Customer-provided user identifier.")
     link: Optional[WorkflowRunSharedLink] = None
     created_at: Optional[datetime] = Field(default=None, description="The date and time when the Workflow Run was created.")
     updated_at: Optional[datetime] = Field(default=None, description="The date and time when the Workflow Run was last updated.")
     custom_data: Optional[Dict[str, Any]] = Field(default=None, description="Object with Custom Input Data to be used in the Workflow Run.")
     additional_properties: Dict[str, Any] = {}
-    __properties: ClassVar[List[str]] = ["applicant_id", "workflow_id", "tags", "link", "created_at", "updated_at", "custom_data"]
+    __properties: ClassVar[List[str]] = ["applicant_id", "workflow_id", "tags", "customer_user_id", "link", "created_at", "updated_at", "custom_data"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -108,6 +109,7 @@ class WorkflowRunBuilder(BaseModel):
             "applicant_id": obj.get("applicant_id"),
             "workflow_id": obj.get("workflow_id"),
             "tags": obj.get("tags"),
+            "customer_user_id": obj.get("customer_user_id"),
             "link": WorkflowRunSharedLink.from_dict(obj["link"]) if obj.get("link") is not None else None,
             "created_at": obj.get("created_at"),
             "updated_at": obj.get("updated_at"),

onfido/models/workflow_run_response.py

@@ -34,8 +34,9 @@ class WorkflowRunResponse(BaseModel):
     output: Optional[Dict[str, Any]] = Field(default=None, description="Output object contains all of the properties configured on the Workflow version.")
     reasons: Optional[List[StrictStr]] = Field(default=None, description="The reasons the Workflow Run outcome was reached. Configurable when creating the Workflow version.")
     error: Optional[WorkflowRunResponseError] = None
+    sdk_token: Optional[StrictStr] = Field(default=None, description="Client token to use when loading this workflow run in the Onfido SDK.")
     additional_properties: Dict[str, Any] = {}
-    __properties: ClassVar[List[str]] = ["id", "workflow_version_id", "dashboard_url", "status", "output", "reasons", "error"]
+    __properties: ClassVar[List[str]] = ["id", "workflow_version_id", "dashboard_url", "status", "output", "reasons", "error", "sdk_token"]
 
     @field_validator('status')
     def status_validate_enum(cls, value):
@@ -96,6 +97,11 @@ class WorkflowRunResponse(BaseModel):
             for _key, _value in self.additional_properties.items():
                 _dict[_key] = _value
 
+        # set to None if sdk_token (nullable) is None
+        # and model_fields_set contains the field
+        if self.sdk_token is None and "sdk_token" in self.model_fields_set:
+            _dict['sdk_token'] = None
+
         return _dict
 
     @classmethod
@@ -114,7 +120,8 @@ class WorkflowRunResponse(BaseModel):
             "status": obj.get("status"),
             "output": obj.get("output"),
             "reasons": obj.get("reasons"),
-            "error": WorkflowRunResponseError.from_dict(obj["error"]) if obj.get("error") is not None else None
+            "error": WorkflowRunResponseError.from_dict(obj["error"]) if obj.get("error") is not None else None,
+            "sdk_token": obj.get("sdk_token")
         })
         # store additional fields in additional_properties
         for _key in obj.keys():

onfido/models/workflow_run_shared.py

@@ -32,11 +32,12 @@ class WorkflowRunShared(BaseModel):
     applicant_id: StrictStr = Field(description="The unique identifier for the Applicant.")
     workflow_id: StrictStr = Field(description="The unique identifier for the Workflow.")
     tags: Optional[Annotated[List[Annotated[str, Field(min_length=1, strict=True, max_length=128)]], Field(max_length=30)]] = Field(default=None, description="Tags or labels assigned to the workflow run.")
+    customer_user_id: Optional[Annotated[str, Field(strict=True, max_length=256)]] = Field(default=None, description="Customer-provided user identifier.")
     link: Optional[WorkflowRunSharedLink] = None
     created_at: Optional[datetime] = Field(default=None, description="The date and time when the Workflow Run was created.")
     updated_at: Optional[datetime] = Field(default=None, description="The date and time when the Workflow Run was last updated.")
     additional_properties: Dict[str, Any] = {}
-    __properties: ClassVar[List[str]] = ["applicant_id", "workflow_id", "tags", "link", "created_at", "updated_at"]
+    __properties: ClassVar[List[str]] = ["applicant_id", "workflow_id", "tags", "customer_user_id", "link", "created_at", "updated_at"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -107,6 +108,7 @@ class WorkflowRunShared(BaseModel):
             "applicant_id": obj.get("applicant_id"),
             "workflow_id": obj.get("workflow_id"),
             "tags": obj.get("tags"),
+            "customer_user_id": obj.get("customer_user_id"),
             "link": WorkflowRunSharedLink.from_dict(obj["link"]) if obj.get("link") is not None else None,
             "created_at": obj.get("created_at"),
             "updated_at": obj.get("updated_at")

{onfido_python-3.3.0.dist-info → onfido_python-3.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: onfido-python
-Version: 3.3.0
+Version: 3.5.0
 Summary: Python library for the Onfido API
 Home-page: 
 Author: OpenAPI Generator community

{onfido_python-3.3.0.dist-info → onfido_python-3.5.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
-onfido/__init__.py,sha256=oZ8T3TqtvOz-mDpbgg2FIAptR9vAbVUsYcGLmaJkv8Y,27053
-onfido/api_client.py,sha256=CGsFK2H5x8VO4yXLH8nA7YyxSob2FosUT3vauvu3u5w,26205
+onfido/__init__.py,sha256=4QGns9SEWf_X0ehNok5nrkh0twv6vbuzqgMQulT9STE,28122
+onfido/api_client.py,sha256=jFcZLl-A1o41-OuODqAeDg1kec0zV4l-UREnE2_G7z4,26205
 onfido/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
-onfido/configuration.py,sha256=DiBi_YlOW9Hzhglao7GZB3LJGGqM4DOiDmfo5GnipNA,14613
+onfido/configuration.py,sha256=1g7ptNPSv8xZJ6fptFN5K7oDGWLl7HnpQ2vK_9T9Xrc,14613
 onfido/exceptions.py,sha256=5W4DJIPVwIzljxoedh5czPXOTBaq6CTTVD92h5ZyN88,5894
 onfido/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onfido/rest.py,sha256=NSJRLqL8U0UzO2YY0KCP4_BmvhOedRHC7zGVTrJ1VFU,9415
 onfido/webhook_event_verifier.py,sha256=3BSbY5D8NTXDbxCX0POuyu5a09dEeWgmikrTe_pttkI,814
 onfido/api/__init__.py,sha256=hqeJm_GD67zukfFQ-H5PPPxYgZZ0DKOMPGTNRAjc3gw,94
 onfido/api/default_api.py,sha256=Eelike5MvHvPpw8u8KchC9Bfn4sPkjMk7TH0LyeHTMs,687639
-onfido/models/__init__.py,sha256=XJ5d4YV52FNXwBYQabTrtVBd-Y61_po8BdxlCJd-prg,26401
+onfido/models/__init__.py,sha256=-QcukmPFARoksV2q0eTy12YfkdWQdLhn9ROyLOMJT4U,27470
 onfido/models/address.py,sha256=47oVzKVhn6Qxd24HMIuAQmVKgHPyfOnlFmBnthi2wOE,6812
 onfido/models/address_builder.py,sha256=SjuOn2_T7Yic2l7qhaxd-euaijx85BziRkunp5j292M,6840
 onfido/models/address_shared.py,sha256=WSQNw_W-V63Jgsh1Jf6KYWb4qm-eOW1URx_8r0LBUMk,6836
@@ -248,7 +248,15 @@ onfido/models/watchlist_aml_breakdown_sanction.py,sha256=E8ey_9TUZVRzRg1WRN_XxRs
 onfido/models/watchlist_aml_properties.py,sha256=VH3M6wqR8GY4DUsAkllaMVeH7osDNFcS89xqGrCpWqQ,3244
 onfido/models/watchlist_aml_report.py,sha256=PFdQjkyh61nxjcbb-CFisvaO8gklGG2LRvNNxkPpqaY,5867
 onfido/models/watchlist_enhanced_breakdown.py,sha256=DHuLezE2g-TArnMImvMeNlkuOGxjuyxinSRQeuuzJS0,5231
-onfido/models/watchlist_enhanced_properties.py,sha256=cOFo0at_AmldyezBsAgy2E1ym5z_7hsXwbqegtb2oK0,3264
+onfido/models/watchlist_enhanced_properties.py,sha256=fjGJvhawrdezM4nuWxuQRfAM9JipJwm_gQgNH49f3TM,3810
+onfido/models/watchlist_enhanced_properties_records_inner.py,sha256=Tnj1BuHGkzctM3FqqP5J5esFCseycG_y2g18LFu1_IY,8315
+onfido/models/watchlist_enhanced_properties_records_inner_address_inner.py,sha256=qHo2B1hiZsRMjgOT5xmaJpv4r5FLt44sOb4G8i_PQCM,3778
+onfido/models/watchlist_enhanced_properties_records_inner_alias_inner.py,sha256=iwYH-kOv-N8oPFn31T9drEl8ezxH84X1Th682Kh2fBs,3286
+onfido/models/watchlist_enhanced_properties_records_inner_associate_inner.py,sha256=4VPf3enaMlXH8h7B64IVeup-8Uu1HjmPKrwslfzXI0Y,3488
+onfido/models/watchlist_enhanced_properties_records_inner_attribute_inner.py,sha256=Hlo1PBhvhw8Y9SfhpdeT_vAaT0OZr7zkgqISV5uT36k,3338
+onfido/models/watchlist_enhanced_properties_records_inner_event_inner.py,sha256=_RYJKwrt71ayppXfZS4jAaCb1WkRlxQdLwOjwpEzgTQ,4095
+onfido/models/watchlist_enhanced_properties_records_inner_event_inner_source.py,sha256=XBLXd--mRvN-PNPqjtrCqfZwaLa45ul3Xwwj1hb3TOU,3563
+onfido/models/watchlist_enhanced_properties_records_inner_source_inner.py,sha256=WijE3B3xOJWJYqNPrQrQxdqvfJ2_rTM4ZBD9GWSak-4,3538
 onfido/models/watchlist_enhanced_report.py,sha256=dMT9GqZZAGxYQUOT0yhck9TS_mjsu1bn_sPTOG2wHls,5927
 onfido/models/watchlist_monitor.py,sha256=J6YoiTB5FI4QjhvSGlgX1WWxds2pcKzLhLlE88mWOmQ,4680
 onfido/models/watchlist_monitor_builder.py,sha256=G0VuDZqa8XAQ4wYrDl-h4YYP2E5eMhUjH_02IxszThI,3866
@@ -277,15 +285,15 @@ onfido/models/webhook_update.py,sha256=gHE4t1uN84tbCLAcXv5ntfV-HHsWMNCcxjqsDG-r3
 onfido/models/webhook_updater.py,sha256=6Ff3y5eObsgIDFON-LOjPNyOCbCQ3PF7Eb-dvN6mpuc,4196
 onfido/models/webhooks_list.py,sha256=t3KMrohj-rTiW0VJN5KLsicNIsAYZXXV52aieIteI3E,3422
 onfido/models/webhooks_resend_item.py,sha256=huJSQx0TfXawHiGG7ftxQH399DeK0xWsvTTSLXKM4Nw,3356
-onfido/models/workflow_run.py,sha256=Dy7a7fLvT1Z7aZPwCdXw69QSb9kE26k2kXq8UBEkx1s,6566
-onfido/models/workflow_run_builder.py,sha256=_gi9ZqIP59_RHOQ0eatxwCiiELpXbNgZzXT_BqmoyaM,4772
+onfido/models/workflow_run.py,sha256=aLrcrwxH8adftdhtAiaoi0D_7p9_IzBXtxUxWdzqJjs,7223
+onfido/models/workflow_run_builder.py,sha256=gOyviRc3pira1qTmC17fDI7-4N_fPq6Ts82-WCvvXtQ,5008
 onfido/models/workflow_run_request.py,sha256=IGCpkcvqn6kJ2L2nZeuBHNeANqcSUfvx0IgcKOqv-4s,3153
-onfido/models/workflow_run_response.py,sha256=YKYOf78z7GA2IG0B_EDJMqEtdqssVdzzhC5il0Lceaw,4990
+onfido/models/workflow_run_response.py,sha256=V02gQYrH43UK4kQcwxPjnadrty9Ffy2QiI7M62zCVA4,5411
 onfido/models/workflow_run_response_error.py,sha256=93xJUVTdo4PUsMzOdcsAifRWlZiTh6nO-nDPUc2SMTs,3311
-onfido/models/workflow_run_shared.py,sha256=fHcZBs61MokjwyaAD1tDKoefpoTwM-DCeiBkjV5n6E8,4561
+onfido/models/workflow_run_shared.py,sha256=pzWbYKouw716jCiNAdSGfWyjdTdx-9T6ioKsoQDZ9hs,4797
 onfido/models/workflow_run_shared_link.py,sha256=8uAlWkhDF9g_7CuVfhoAXgZqcv6LZHOIc4c_CqMxths,4682
-onfido_python-3.3.0.dist-info/LICENSE,sha256=SKY_O1OkFX8yNWFuVVfYTsXvN46jsgtff-xReserHw4,1073
-onfido_python-3.3.0.dist-info/METADATA,sha256=40NH6GKoTftSKonaG_9fSJYypX6SsLHjEKpm3FP2Nxg,482
-onfido_python-3.3.0.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-onfido_python-3.3.0.dist-info/top_level.txt,sha256=NHu8xI4S4Avh7xUark3dpdk9atpIVgyf-ptjHXU0-Ns,7
-onfido_python-3.3.0.dist-info/RECORD,,
+onfido_python-3.5.0.dist-info/LICENSE,sha256=SKY_O1OkFX8yNWFuVVfYTsXvN46jsgtff-xReserHw4,1073
+onfido_python-3.5.0.dist-info/METADATA,sha256=vUdG3DWR6Z-NxADlYoSprDNmWupK74f1CzEbZy8gDSE,482
+onfido_python-3.5.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+onfido_python-3.5.0.dist-info/top_level.txt,sha256=NHu8xI4S4Avh7xUark3dpdk9atpIVgyf-ptjHXU0-Ns,7
+onfido_python-3.5.0.dist-info/RECORD,,

{onfido_python-3.3.0.dist-info → onfido_python-3.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.3.0)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any