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

onfido/models/known_faces_report.py

@@ -92,9 +92,9 @@ class KnownFacesReport(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in documents (list)
         _items = []
         if self.documents:
-            for _item in self.documents:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_documents in self.documents:
+                if _item_documents:
+                    _items.append(_item_documents.to_dict())
             _dict['documents'] = _items
         # override the default output from pydantic by calling `to_dict()` of breakdown
         if self.breakdown:

onfido/models/live_photos_list.py

@@ -75,9 +75,9 @@ class LivePhotosList(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in live_photos (list)
         _items = []
         if self.live_photos:
-            for _item in self.live_photos:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_live_photos in self.live_photos:
+                if _item_live_photos:
+                    _items.append(_item_live_photos.to_dict())
             _dict['live_photos'] = _items
         # puts key-value pairs in additional_properties in the top level
         if self.additional_properties is not None:

onfido/models/live_videos_list.py

@@ -75,9 +75,9 @@ class LiveVideosList(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in live_videos (list)
         _items = []
         if self.live_videos:
-            for _item in self.live_videos:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_live_videos in self.live_videos:
+                if _item_live_videos:
+                    _items.append(_item_live_videos.to_dict())
             _dict['live_videos'] = _items
         # puts key-value pairs in additional_properties in the top level
         if self.additional_properties is not None:

onfido/models/motion_captures_list.py

@@ -75,9 +75,9 @@ class MotionCapturesList(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in motion_captures (list)
         _items = []
         if self.motion_captures:
-            for _item in self.motion_captures:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_motion_captures in self.motion_captures:
+                if _item_motion_captures:
+                    _items.append(_item_motion_captures.to_dict())
             _dict['motion_captures'] = _items
         # puts key-value pairs in additional_properties in the top level
         if self.additional_properties is not None:

onfido/models/proof_of_address_report.py

@@ -92,9 +92,9 @@ class ProofOfAddressReport(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in documents (list)
         _items = []
         if self.documents:
-            for _item in self.documents:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_documents in self.documents:
+                if _item_documents:
+                    _items.append(_item_documents.to_dict())
             _dict['documents'] = _items
         # override the default output from pydantic by calling `to_dict()` of breakdown
         if self.breakdown:

onfido/models/repeat_attempts_list.py

@@ -80,9 +80,9 @@ class RepeatAttemptsList(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in repeat_attempts (list)
         _items = []
         if self.repeat_attempts:
-            for _item in self.repeat_attempts:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_repeat_attempts in self.repeat_attempts:
+                if _item_repeat_attempts:
+                    _items.append(_item_repeat_attempts.to_dict())
             _dict['repeat_attempts'] = _items
         # puts key-value pairs in additional_properties in the top level
         if self.additional_properties is not None:

onfido/models/report_shared.py

@@ -88,9 +88,9 @@ class ReportShared(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in documents (list)
         _items = []
         if self.documents:
-            for _item in self.documents:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_documents in self.documents:
+                if _item_documents:
+                    _items.append(_item_documents.to_dict())
             _dict['documents'] = _items
         # puts key-value pairs in additional_properties in the top level
         if self.additional_properties is not None:

onfido/models/reports_list.py

@@ -75,9 +75,9 @@ class ReportsList(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in reports (list)
         _items = []
         if self.reports:
-            for _item in self.reports:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_reports in self.reports:
+                if _item_reports:
+                    _items.append(_item_reports.to_dict())
             _dict['reports'] = _items
         # puts key-value pairs in additional_properties in the top level
         if self.additional_properties is not None:

onfido/models/task_item.py

@@ -18,7 +18,7 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
 from typing_extensions import Annotated
 from typing import Optional, Set
@@ -29,11 +29,13 @@ class TaskItem(BaseModel):
     TaskItem
     """ # noqa: E501
     id: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The identifier for the Task.")
+    workflow_run_id: Optional[StrictStr] = Field(default=None, description="The workflow run id the task belongs to.")
     task_def_id: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The identifier for the Task Definition.")
+    task_def_version: Optional[StrictStr] = Field(default=None, description="The task definition version.")
     created_at: Optional[datetime] = Field(default=None, description="The date and time when the Task was created.")
     updated_at: Optional[datetime] = Field(default=None, description="The date and time when the Task was last updated.")
     additional_properties: Dict[str, Any] = {}
-    __properties: ClassVar[List[str]] = ["id", "task_def_id", "created_at", "updated_at"]
+    __properties: ClassVar[List[str]] = ["id", "workflow_run_id", "task_def_id", "task_def_version", "created_at", "updated_at"]
 
     @field_validator('id')
     def id_validate_regular_expression(cls, value):
@@ -101,6 +103,11 @@ class TaskItem(BaseModel):
             for _key, _value in self.additional_properties.items():
                 _dict[_key] = _value
 
+        # set to None if task_def_version (nullable) is None
+        # and model_fields_set contains the field
+        if self.task_def_version is None and "task_def_version" in self.model_fields_set:
+            _dict['task_def_version'] = None
+
         return _dict
 
     @classmethod
@@ -114,7 +121,9 @@ class TaskItem(BaseModel):
 
         _obj = cls.model_validate({
             "id": obj.get("id"),
+            "workflow_run_id": obj.get("workflow_run_id"),
             "task_def_id": obj.get("task_def_id"),
+            "task_def_version": obj.get("task_def_version"),
             "created_at": obj.get("created_at"),
             "updated_at": obj.get("updated_at")
         })

onfido/models/us_driving_licence_report.py

@@ -92,9 +92,9 @@ class UsDrivingLicenceReport(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in documents (list)
         _items = []
         if self.documents:
-            for _item in self.documents:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_documents in self.documents:
+                if _item_documents:
+                    _items.append(_item_documents.to_dict())
             _dict['documents'] = _items
         # override the default output from pydantic by calling `to_dict()` of breakdown
         if self.breakdown:

onfido/models/watchlist_aml_report.py

@@ -92,9 +92,9 @@ class WatchlistAmlReport(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in documents (list)
         _items = []
         if self.documents:
-            for _item in self.documents:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_documents in self.documents:
+                if _item_documents:
+                    _items.append(_item_documents.to_dict())
             _dict['documents'] = _items
         # override the default output from pydantic by calling `to_dict()` of breakdown
         if self.breakdown:

onfido/models/watchlist_enhanced_properties.py

@@ -75,9 +75,9 @@ class WatchlistEnhancedProperties(BaseModel):
         # 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())
+            for _item_records in self.records:
+                if _item_records:
+                    _items.append(_item_records.to_dict())
             _dict['records'] = _items
         # puts key-value pairs in additional_properties in the top level
         if self.additional_properties is not None:

onfido/models/watchlist_enhanced_properties_records_inner.py

@@ -88,44 +88,44 @@ class WatchlistEnhancedPropertiesRecordsInner(BaseModel):
         # 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())
+            for _item_address in self.address:
+                if _item_address:
+                    _items.append(_item_address.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())
+            for _item_alias in self.alias:
+                if _item_alias:
+                    _items.append(_item_alias.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())
+            for _item_associate in self.associate:
+                if _item_associate:
+                    _items.append(_item_associate.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())
+            for _item_attribute in self.attribute:
+                if _item_attribute:
+                    _items.append(_item_attribute.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())
+            for _item_event in self.event:
+                if _item_event:
+                    _items.append(_item_event.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())
+            for _item_source in self.source:
+                if _item_source:
+                    _items.append(_item_source.to_dict())
             _dict['source'] = _items
         # puts key-value pairs in additional_properties in the top level
         if self.additional_properties is not None:

onfido/models/watchlist_enhanced_report.py

@@ -92,9 +92,9 @@ class WatchlistEnhancedReport(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in documents (list)
         _items = []
         if self.documents:
-            for _item in self.documents:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_documents in self.documents:
+                if _item_documents:
+                    _items.append(_item_documents.to_dict())
             _dict['documents'] = _items
         # override the default output from pydantic by calling `to_dict()` of breakdown
         if self.breakdown:

onfido/models/watchlist_monitor_matches_list.py

@@ -75,9 +75,9 @@ class WatchlistMonitorMatchesList(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in matches (list)
         _items = []
         if self.matches:
-            for _item in self.matches:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_matches in self.matches:
+                if _item_matches:
+                    _items.append(_item_matches.to_dict())
             _dict['matches'] = _items
         # puts key-value pairs in additional_properties in the top level
         if self.additional_properties is not None:

onfido/models/watchlist_monitors_list.py

@@ -75,9 +75,9 @@ class WatchlistMonitorsList(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in monitors (list)
         _items = []
         if self.monitors:
-            for _item in self.monitors:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_monitors in self.monitors:
+                if _item_monitors:
+                    _items.append(_item_monitors.to_dict())
             _dict['monitors'] = _items
         # puts key-value pairs in additional_properties in the top level
         if self.additional_properties is not None:

onfido/models/watchlist_peps_only_report.py

@@ -92,9 +92,9 @@ class WatchlistPepsOnlyReport(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in documents (list)
         _items = []
         if self.documents:
-            for _item in self.documents:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_documents in self.documents:
+                if _item_documents:
+                    _items.append(_item_documents.to_dict())
             _dict['documents'] = _items
         # override the default output from pydantic by calling `to_dict()` of breakdown
         if self.breakdown:

onfido/models/watchlist_sanctions_only_report.py

@@ -92,9 +92,9 @@ class WatchlistSanctionsOnlyReport(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in documents (list)
         _items = []
         if self.documents:
-            for _item in self.documents:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_documents in self.documents:
+                if _item_documents:
+                    _items.append(_item_documents.to_dict())
             _dict['documents'] = _items
         # override the default output from pydantic by calling `to_dict()` of breakdown
         if self.breakdown:

onfido/models/watchlist_standard_report.py

@@ -92,9 +92,9 @@ class WatchlistStandardReport(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in documents (list)
         _items = []
         if self.documents:
-            for _item in self.documents:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_documents in self.documents:
+                if _item_documents:
+                    _items.append(_item_documents.to_dict())
             _dict['documents'] = _items
         # override the default output from pydantic by calling `to_dict()` of breakdown
         if self.breakdown:

onfido/models/webhook_event_object_status.py

@@ -0,0 +1,54 @@
+# 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 json
+from enum import Enum
+from typing_extensions import Self
+
+
+class WebhookEventObjectStatus(str, Enum):
+    """
+    The current state of the object, if available.
+    """
+
+    """
+    allowed enum values
+    """
+    PROCESSING = 'processing'
+    AWAITING_INPUT = 'awaiting_input'
+    AWAITING_CLIENT_INPUT = 'awaiting_client_input'
+    APPROVED = 'approved'
+    DECLINED = 'declined'
+    REVIEW = 'review'
+    ABANDONED = 'abandoned'
+    ERROR = 'error'
+    STARTED = 'started'
+    CANCELLED = 'cancelled'
+    COMPLETED = 'completed'
+    AWAITING_DATA = 'awaiting_data'
+    AWAITING_APPROVAL = 'awaiting_approval'
+    COMPLETE = 'complete'
+    WITHDRAWN = 'withdrawn'
+    IN_PROGRESS = 'in_progress'
+    AWAITING_APPLICANT = 'awaiting_applicant'
+    PAUSED = 'paused'
+    REOPENED = 'reopened'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of WebhookEventObjectStatus from a JSON string"""
+        return cls(json.loads(json_str))
+
+

onfido/models/webhook_event_payload.py

@@ -17,9 +17,11 @@ 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.webhook_event_payload_object import WebhookEventPayloadObject
+from onfido.models.webhook_event_payload_resource import WebhookEventPayloadResource
+from onfido.models.webhook_event_resource_type import WebhookEventResourceType
 from onfido.models.webhook_event_type import WebhookEventType
 from typing import Optional, Set
 from typing_extensions import Self
@@ -28,10 +30,10 @@ class WebhookEventPayload(BaseModel):
     """
     WebhookEventPayload
     """ # noqa: E501
-    resource_type: StrictStr = Field(description="Indicates the resource affected by this event.")
+    resource_type: WebhookEventResourceType = Field(description="Indicates the resource affected by this event.")
     action: Optional[WebhookEventType] = Field(default=None, description="The event that triggered this webhook.")
     object: Optional[WebhookEventPayloadObject] = None
-    resource: Optional[Dict[str, Any]] = Field(default=None, description="The resource affected by this event.")
+    resource: Optional[WebhookEventPayloadResource] = None
     additional_properties: Dict[str, Any] = {}
     __properties: ClassVar[List[str]] = ["resource_type", "action", "object", "resource"]
 
@@ -79,6 +81,9 @@ class WebhookEventPayload(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of object
         if self.object:
             _dict['object'] = self.object.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of resource
+        if self.resource:
+            _dict['resource'] = self.resource.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():
@@ -99,7 +104,7 @@ class WebhookEventPayload(BaseModel):
             "resource_type": obj.get("resource_type"),
             "action": obj.get("action"),
             "object": WebhookEventPayloadObject.from_dict(obj["object"]) if obj.get("object") is not None else None,
-            "resource": obj.get("resource")
+            "resource": WebhookEventPayloadResource.from_dict(obj["resource"]) if obj.get("resource") is not None else None
         })
         # store additional fields in additional_properties
         for _key in obj.keys():

onfido/models/webhook_event_payload_object.py

@@ -20,6 +20,7 @@ import json
 from datetime import datetime
 from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
+from onfido.models.webhook_event_object_status import WebhookEventObjectStatus
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -28,7 +29,7 @@ class WebhookEventPayloadObject(BaseModel):
     The object affected by this event.
     """ # noqa: E501
     id: StrictStr = Field(description="The unique identifier of the resource.")
-    status: Optional[StrictStr] = Field(default=None, description="The current state of the object, if available.")
+    status: Optional[WebhookEventObjectStatus] = None
     started_at_iso8601: Optional[datetime] = Field(default=None, description="The date and time when the operation was started, if available.")
     completed_at_iso8601: Optional[datetime] = Field(default=None, description="The date and time when the operation was completed, if available.")
     href: StrictStr = Field(description="The uri of the resource.")

onfido/models/webhook_event_payload_resource.py

@@ -0,0 +1,158 @@
+# coding: utf-8
+
+"""
+    Onfido API v3.6
+
+    The Onfido API (v3.6)
+
+    The version of the OpenAPI document: v3.6
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from onfido.models.workflow_run_error import WorkflowRunError
+from onfido.models.workflow_run_link import WorkflowRunLink
+from typing import Optional, Set
+from typing_extensions import Self
+
+class WebhookEventPayloadResource(BaseModel):
+    """
+    The resource affected by this event.
+    """ # noqa: E501
+    id: Optional[StrictStr] = Field(default=None, description="The identifier of the resource.")
+    applicant_id: Optional[StrictStr] = Field(default=None, description="The unique identifier for the Applicant.")
+    created_at: Optional[datetime] = Field(default=None, description="The date and time when the resource was created.")
+    updated_at: Optional[datetime] = Field(default=None, description="The date and time when the resource was last updated.")
+    dashboard_url: Optional[StrictStr] = Field(default=None, description="The URL for viewing the resource on Onfido Dashboard.")
+    workflow_id: Optional[StrictStr] = Field(default=None, description="The unique identifier for the Workflow.")
+    workflow_run_id: Optional[StrictStr] = None
+    workflow_version_id: Optional[StrictInt] = Field(default=None, description="The identifier for the Workflow version.")
+    task_def_id: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The identifier for the Task Definition.")
+    task_def_version: Optional[StrictStr] = Field(default=None, description="The task definition version.")
+    input: Optional[Dict[str, Any]] = Field(default=None, description="Input object with the fields used by the Task execution.")
+    output: Optional[Dict[str, Any]] = Field(default=None, description="Output object with the fields produced by the Task execution.")
+    reasons: Optional[List[StrictStr]] = Field(default=None, description="The reasons the Workflow Run outcome was reached. Configurable when creating the Workflow Version.")
+    link: Optional[WorkflowRunLink] = Field(default=None, description="Object for the configuration of the Workflow Run link.")
+    error: Optional[WorkflowRunError] = Field(default=None, description="Error object that details why a Workflow Run is in Error status.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["id", "applicant_id", "created_at", "updated_at", "dashboard_url", "workflow_id", "workflow_run_id", "workflow_version_id", "task_def_id", "task_def_version", "input", "output", "reasons", "link", "error"]
+
+    @field_validator('task_def_id')
+    def task_def_id_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9a-z_-]+$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9a-z_-]+$/")
+        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 WebhookEventPayloadResource 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 link
+        if self.link:
+            _dict['link'] = self.link.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of error
+        if self.error:
+            _dict['error'] = self.error.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
+
+        # set to None if task_def_version (nullable) is None
+        # and model_fields_set contains the field
+        if self.task_def_version is None and "task_def_version" in self.model_fields_set:
+            _dict['task_def_version'] = None
+
+        # set to None if output (nullable) is None
+        # and model_fields_set contains the field
+        if self.output is None and "output" in self.model_fields_set:
+            _dict['output'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of WebhookEventPayloadResource from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "applicant_id": obj.get("applicant_id"),
+            "created_at": obj.get("created_at"),
+            "updated_at": obj.get("updated_at"),
+            "dashboard_url": obj.get("dashboard_url"),
+            "workflow_id": obj.get("workflow_id"),
+            "workflow_run_id": obj.get("workflow_run_id"),
+            "workflow_version_id": obj.get("workflow_version_id"),
+            "task_def_id": obj.get("task_def_id"),
+            "task_def_version": obj.get("task_def_version"),
+            "input": obj.get("input"),
+            "output": obj.get("output"),
+            "reasons": obj.get("reasons"),
+            "link": WorkflowRunLink.from_dict(obj["link"]) if obj.get("link") is not None else None,
+            "error": WorkflowRunError.from_dict(obj["error"]) if obj.get("error") 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
+
+