onfido-python 2.10.1__py3-none-any.whl → 3.2.0__py3-none-any.whl

onfido/models/device_intelligence_breakdown_breakdown_device_breakdown.py

@@ -0,0 +1,114 @@
+# coding: utf-8
+
+"""
+    Onfido API v3.6
+
+    The Onfido API (v3.6)
+
+    The version of the OpenAPI document: v3.6
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from onfido.models.document_breakdown_data_comparison_breakdown_issuing_country import DocumentBreakdownDataComparisonBreakdownIssuingCountry
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DeviceIntelligenceBreakdownBreakdownDeviceBreakdown(BaseModel):
+    """
+    DeviceIntelligenceBreakdownBreakdownDeviceBreakdown
+    """ # noqa: E501
+    application_authenticity: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    device_integrity: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    device_reputation: Optional[DocumentBreakdownDataComparisonBreakdownIssuingCountry] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["application_authenticity", "device_integrity", "device_reputation"]
+
+    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 DeviceIntelligenceBreakdownBreakdownDeviceBreakdown 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 application_authenticity
+        if self.application_authenticity:
+            _dict['application_authenticity'] = self.application_authenticity.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of device_integrity
+        if self.device_integrity:
+            _dict['device_integrity'] = self.device_integrity.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of device_reputation
+        if self.device_reputation:
+            _dict['device_reputation'] = self.device_reputation.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 DeviceIntelligenceBreakdownBreakdownDeviceBreakdown from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "application_authenticity": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["application_authenticity"]) if obj.get("application_authenticity") is not None else None,
+            "device_integrity": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["device_integrity"]) if obj.get("device_integrity") is not None else None,
+            "device_reputation": DocumentBreakdownDataComparisonBreakdownIssuingCountry.from_dict(obj["device_reputation"]) if obj.get("device_reputation") 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_breakdown_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 DeviceIntelligenceBreakdownProperties(BaseModel):
+    """
+    DeviceIntelligenceBreakdownProperties
+    """ # 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 DeviceIntelligenceBreakdownProperties 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 DeviceIntelligenceBreakdownProperties 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_breakdown_properties_device.py

@@ -0,0 +1,189 @@
+# 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, StrictBool, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DeviceIntelligenceBreakdownPropertiesDevice(BaseModel):
+    """
+    DeviceIntelligenceBreakdownPropertiesDevice
+    """ # noqa: E501
+    sdk_version: Optional[StrictStr] = Field(default=None, description="The SDK version that was used.")
+    sdk_source: Optional[StrictStr] = Field(default=None, description="The SDK used to upload the media.")
+    authentication_type: Optional[StrictStr] = Field(default=None, description="The token used to authenticate the request.")
+    raw_model: Optional[StrictStr] = Field(default=None, description="The model as set by the phone manufacturer (for Android and iOS) or the browser manufacturer (for Web). The model can be presented in name or number form depending on each manufacturer implementation.")
+    os: Optional[StrictStr] = Field(default=None, description="The operating system of the device. The value came from manufacturer implementation (for Android and iOS) or browser's user agent (for Web).")
+    browser: Optional[StrictStr] = Field(default=None, description="The browser name reported by the browser's user agent.")
+    emulator: Optional[StrictBool] = Field(default=None, description="Whether the device is an emulator.")
+    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.")
+    true_os: Optional[StrictStr] = Field(default=None, description="The true operating system of the device.")
+    os_anomaly: Optional[StrictStr] = Field(default=None, description="The likelihood of an operating system anomaly between the true OS and the OS sent by the device.")
+    rooted: Optional[StrictBool] = Field(default=None, description="Whether the device is rooted.")
+    remote_software: Optional[StrictBool] = Field(default=None, description="Whether the device is controlled via remote software.")
+    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.")
+    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.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["sdk_version", "sdk_source", "authentication_type", "raw_model", "os", "browser", "emulator", "randomized_device", "fake_network_request", "true_os", "os_anomaly", "rooted", "remote_software", "ip_reputation", "device_fingerprint_reuse", "single_device_used", "document_capture", "biometric_capture"]
+
+    @field_validator('sdk_source')
+    def sdk_source_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['onfido-android-sdk', 'onfido-ios-sdk', 'onfido-web-sdk']):
+            raise ValueError("must be one of enum values ('onfido-android-sdk', 'onfido-ios-sdk', 'onfido-web-sdk')")
+        return value
+
+    @field_validator('authentication_type')
+    def authentication_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['sdk_token', 'mobile_token', 'api_token']):
+            raise ValueError("must be one of enum values ('sdk_token', 'mobile_token', 'api_token')")
+        return value
+
+    @field_validator('ip_reputation')
+    def ip_reputation_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['NOT_ENOUGH_DATA', 'HIGH_RISK', 'LOW_RISK']):
+            raise ValueError("must be one of enum values ('NOT_ENOUGH_DATA', 'HIGH_RISK', 'LOW_RISK')")
+        return value
+
+    @field_validator('document_capture')
+    def document_capture_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['live', 'unknown_method']):
+            raise ValueError("must be one of enum values ('live', 'unknown_method')")
+        return value
+
+    @field_validator('biometric_capture')
+    def biometric_capture_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['live', 'unknown_method']):
+            raise ValueError("must be one of enum values ('live', 'unknown_method')")
+        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 DeviceIntelligenceBreakdownPropertiesDevice 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
+
+        # set to None if single_device_used (nullable) is None
+        # and model_fields_set contains the field
+        if self.single_device_used is None and "single_device_used" in self.model_fields_set:
+            _dict['single_device_used'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DeviceIntelligenceBreakdownPropertiesDevice from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "sdk_version": obj.get("sdk_version"),
+            "sdk_source": obj.get("sdk_source"),
+            "authentication_type": obj.get("authentication_type"),
+            "raw_model": obj.get("raw_model"),
+            "os": obj.get("os"),
+            "browser": obj.get("browser"),
+            "emulator": obj.get("emulator"),
+            "randomized_device": obj.get("randomized_device"),
+            "fake_network_request": obj.get("fake_network_request"),
+            "true_os": obj.get("true_os"),
+            "os_anomaly": obj.get("os_anomaly"),
+            "rooted": obj.get("rooted"),
+            "remote_software": obj.get("remote_software"),
+            "ip_reputation": obj.get("ip_reputation"),
+            "device_fingerprint_reuse": obj.get("device_fingerprint_reuse"),
+            "single_device_used": obj.get("single_device_used"),
+            "document_capture": obj.get("document_capture"),
+            "biometric_capture": obj.get("biometric_capture")
+        })
+        # 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_breakdown_properties_geolocation.py

@@ -0,0 +1,105 @@
+# 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.country_codes import CountryCodes
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DeviceIntelligenceBreakdownPropertiesGeolocation(BaseModel):
+    """
+    DeviceIntelligenceBreakdownPropertiesGeolocation
+    """ # noqa: E501
+    city: Optional[StrictStr] = Field(default=None, description="City location of the IP address.")
+    region: Optional[StrictStr] = Field(default=None, description="Region location of the IP address.")
+    country: Optional[CountryCodes] = Field(default=None, description="Country location of the IP address in a three letter format.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["city", "region", "country"]
+
+    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 DeviceIntelligenceBreakdownPropertiesGeolocation 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 DeviceIntelligenceBreakdownPropertiesGeolocation from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "city": obj.get("city"),
+            "region": obj.get("region"),
+            "country": obj.get("country")
+        })
+        # 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_breakdown_properties_ip.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, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DeviceIntelligenceBreakdownPropertiesIp(BaseModel):
+    """
+    DeviceIntelligenceBreakdownPropertiesIp
+    """ # noqa: E501
+    address: Optional[StrictStr] = Field(default=None, description="The IP address that uploaded the media.")
+    vpn_detection: Optional[StrictStr] = Field(default=None, description="The likelihood of the network connection being a VPN.")
+    proxy_detection: Optional[StrictStr] = Field(default=None, description="The likelihood of the network connection being a Proxy.")
+    type: Optional[StrictStr] = Field(default=None, description="The type of organization that owns this IP address.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["address", "vpn_detection", "proxy_detection", "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 DeviceIntelligenceBreakdownPropertiesIp 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 DeviceIntelligenceBreakdownPropertiesIp from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "address": obj.get("address"),
+            "vpn_detection": obj.get("vpn_detection"),
+            "proxy_detection": obj.get("proxy_detection"),
+            "type": obj.get("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
+
+