leadping 1.0.0__py3-none-any.whl

leadping/models/automation_trigger.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .automation_trigger_settings import AutomationTrigger_settings
+
+@dataclass
+class AutomationTrigger(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing automation trigger data used by Leadping API contracts.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The human-readable display name shown for this automation trigger.
+    display_name: Optional[str] = None
+    # The unique ID for this automation trigger.
+    id: Optional[str] = None
+    # Whether this automation trigger is enabled.
+    is_enabled: Optional[bool] = None
+    # The settings key-value data carried with this automation trigger; values must be safe to expose in API responses.
+    settings: Optional[AutomationTrigger_settings] = None
+    # The type classification for this automation trigger.
+    type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationTrigger:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: AutomationTrigger
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationTrigger()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .automation_trigger_settings import AutomationTrigger_settings
+
+        from .automation_trigger_settings import AutomationTrigger_settings
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isEnabled": lambda n : setattr(self, 'is_enabled', n.get_bool_value()),
+            "settings": lambda n : setattr(self, 'settings', n.get_object_value(AutomationTrigger_settings)),
+            "type": lambda n : setattr(self, 'type', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("displayName", self.display_name)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isEnabled", self.is_enabled)
+        writer.write_object_value("settings", self.settings)
+        writer.write_str_value("type", self.type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_trigger_settings.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class AutomationTrigger_settings(AdditionalDataHolder, Parsable):
+    """
+    The settings key-value data carried with this automation trigger; values must be safe to expose in API responses.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationTrigger_settings:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: AutomationTrigger_settings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationTrigger_settings()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_validation_result.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class AutomationValidationResult(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing automation validation result data used by Leadping API contracts.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The errors included with this automation validation result.
+    errors: Optional[list[str]] = None
+    # The warnings included with this automation validation result.
+    warnings: Optional[list[str]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationValidationResult:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: AutomationValidationResult
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationValidationResult()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "errors": lambda n : setattr(self, 'errors', n.get_collection_of_primitive_values(str)),
+            "warnings": lambda n : setattr(self, 'warnings', n.get_collection_of_primitive_values(str)),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_collection_of_primitive_values("errors", self.errors)
+        writer.write_collection_of_primitive_values("warnings", self.warnings)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_workflow_action_response.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class AutomationWorkflowActionResponse(AdditionalDataHolder, Parsable):
+    """
+    User-safe action status returned for lead automation workflow visibility.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The actionType property
+    action_type: Optional[str] = None
+    # The actionTypeDisplay property
+    action_type_display: Optional[str] = None
+    # The adminDiagnostics property
+    admin_diagnostics: Optional[str] = None
+    # The completedAt property
+    completed_at: Optional[datetime.datetime] = None
+    # The failedAt property
+    failed_at: Optional[datetime.datetime] = None
+    # The failureCode property
+    failure_code: Optional[str] = None
+    # The id property
+    id: Optional[str] = None
+    # The nextRetryAt property
+    next_retry_at: Optional[datetime.datetime] = None
+    # The retryCount property
+    retry_count: Optional[int] = None
+    # The safeReason property
+    safe_reason: Optional[str] = None
+    # The scheduledAt property
+    scheduled_at: Optional[datetime.datetime] = None
+    # The skippedAt property
+    skipped_at: Optional[datetime.datetime] = None
+    # The startedAt property
+    started_at: Optional[datetime.datetime] = None
+    # The status property
+    status: Optional[str] = None
+    # The statusDisplay property
+    status_display: Optional[str] = None
+    # The stepDisplayName property
+    step_display_name: Optional[str] = None
+    # The stepId property
+    step_id: Optional[str] = None
+    # The stepOrder property
+    step_order: Optional[int] = None
+    # The userSummary property
+    user_summary: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationWorkflowActionResponse:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: AutomationWorkflowActionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationWorkflowActionResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "actionType": lambda n : setattr(self, 'action_type', n.get_str_value()),
+            "actionTypeDisplay": lambda n : setattr(self, 'action_type_display', n.get_str_value()),
+            "adminDiagnostics": lambda n : setattr(self, 'admin_diagnostics', n.get_str_value()),
+            "completedAt": lambda n : setattr(self, 'completed_at', n.get_datetime_value()),
+            "failedAt": lambda n : setattr(self, 'failed_at', n.get_datetime_value()),
+            "failureCode": lambda n : setattr(self, 'failure_code', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "nextRetryAt": lambda n : setattr(self, 'next_retry_at', n.get_datetime_value()),
+            "retryCount": lambda n : setattr(self, 'retry_count', n.get_int_value()),
+            "safeReason": lambda n : setattr(self, 'safe_reason', n.get_str_value()),
+            "scheduledAt": lambda n : setattr(self, 'scheduled_at', n.get_datetime_value()),
+            "skippedAt": lambda n : setattr(self, 'skipped_at', n.get_datetime_value()),
+            "startedAt": lambda n : setattr(self, 'started_at', n.get_datetime_value()),
+            "status": lambda n : setattr(self, 'status', n.get_str_value()),
+            "statusDisplay": lambda n : setattr(self, 'status_display', n.get_str_value()),
+            "stepDisplayName": lambda n : setattr(self, 'step_display_name', n.get_str_value()),
+            "stepId": lambda n : setattr(self, 'step_id', n.get_str_value()),
+            "stepOrder": lambda n : setattr(self, 'step_order', n.get_int_value()),
+            "userSummary": lambda n : setattr(self, 'user_summary', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("actionType", self.action_type)
+        writer.write_str_value("actionTypeDisplay", self.action_type_display)
+        writer.write_str_value("adminDiagnostics", self.admin_diagnostics)
+        writer.write_datetime_value("completedAt", self.completed_at)
+        writer.write_datetime_value("failedAt", self.failed_at)
+        writer.write_str_value("failureCode", self.failure_code)
+        writer.write_str_value("id", self.id)
+        writer.write_datetime_value("nextRetryAt", self.next_retry_at)
+        writer.write_int_value("retryCount", self.retry_count)
+        writer.write_str_value("safeReason", self.safe_reason)
+        writer.write_datetime_value("scheduledAt", self.scheduled_at)
+        writer.write_datetime_value("skippedAt", self.skipped_at)
+        writer.write_datetime_value("startedAt", self.started_at)
+        writer.write_str_value("status", self.status)
+        writer.write_str_value("statusDisplay", self.status_display)
+        writer.write_str_value("stepDisplayName", self.step_display_name)
+        writer.write_str_value("stepId", self.step_id)
+        writer.write_int_value("stepOrder", self.step_order)
+        writer.write_str_value("userSummary", self.user_summary)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_workflow_event_response.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class AutomationWorkflowEventResponse(AdditionalDataHolder, Parsable):
+    """
+    User-safe workflow history event returned for lead automation status.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The actionId property
+    action_id: Optional[str] = None
+    # The adminDiagnostics property
+    admin_diagnostics: Optional[str] = None
+    # The eventType property
+    event_type: Optional[str] = None
+    # The id property
+    id: Optional[str] = None
+    # The occurredAt property
+    occurred_at: Optional[datetime.datetime] = None
+    # The reasonCode property
+    reason_code: Optional[str] = None
+    # The status property
+    status: Optional[str] = None
+    # The statusDisplay property
+    status_display: Optional[str] = None
+    # The stepId property
+    step_id: Optional[str] = None
+    # The summary property
+    summary: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationWorkflowEventResponse:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: AutomationWorkflowEventResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationWorkflowEventResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "actionId": lambda n : setattr(self, 'action_id', n.get_str_value()),
+            "adminDiagnostics": lambda n : setattr(self, 'admin_diagnostics', n.get_str_value()),
+            "eventType": lambda n : setattr(self, 'event_type', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "occurredAt": lambda n : setattr(self, 'occurred_at', n.get_datetime_value()),
+            "reasonCode": lambda n : setattr(self, 'reason_code', n.get_str_value()),
+            "status": lambda n : setattr(self, 'status', n.get_str_value()),
+            "statusDisplay": lambda n : setattr(self, 'status_display', n.get_str_value()),
+            "stepId": lambda n : setattr(self, 'step_id', n.get_str_value()),
+            "summary": lambda n : setattr(self, 'summary', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("actionId", self.action_id)
+        writer.write_str_value("adminDiagnostics", self.admin_diagnostics)
+        writer.write_str_value("eventType", self.event_type)
+        writer.write_str_value("id", self.id)
+        writer.write_datetime_value("occurredAt", self.occurred_at)
+        writer.write_str_value("reasonCode", self.reason_code)
+        writer.write_str_value("status", self.status)
+        writer.write_str_value("statusDisplay", self.status_display)
+        writer.write_str_value("stepId", self.step_id)
+        writer.write_str_value("summary", self.summary)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_workflow_run_response.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .automation_workflow_action_response import AutomationWorkflowActionResponse
+    from .automation_workflow_event_response import AutomationWorkflowEventResponse
+
+@dataclass
+class AutomationWorkflowRunResponse(AdditionalDataHolder, Parsable):
+    """
+    User-safe automation workflow run status returned for a lead.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The actions property
+    actions: Optional[list[AutomationWorkflowActionResponse]] = None
+    # The automationId property
+    automation_id: Optional[str] = None
+    # The automationName property
+    automation_name: Optional[str] = None
+    # The businessId property
+    business_id: Optional[str] = None
+    # The cancelledAt property
+    cancelled_at: Optional[datetime.datetime] = None
+    # The completedAt property
+    completed_at: Optional[datetime.datetime] = None
+    # The correlationId property
+    correlation_id: Optional[str] = None
+    # The currentStepId property
+    current_step_id: Optional[str] = None
+    # The currentStepName property
+    current_step_name: Optional[str] = None
+    # The events property
+    events: Optional[list[AutomationWorkflowEventResponse]] = None
+    # The executionKey property
+    execution_key: Optional[str] = None
+    # The failedAt property
+    failed_at: Optional[datetime.datetime] = None
+    # The id property
+    id: Optional[str] = None
+    # The internalErrorDetails property
+    internal_error_details: Optional[str] = None
+    # The lastActionSummary property
+    last_action_summary: Optional[str] = None
+    # The lastErrorCode property
+    last_error_code: Optional[str] = None
+    # The lastErrorMessage property
+    last_error_message: Optional[str] = None
+    # The lastExecutionAt property
+    last_execution_at: Optional[datetime.datetime] = None
+    # The leadId property
+    lead_id: Optional[str] = None
+    # The maxRetryCount property
+    max_retry_count: Optional[int] = None
+    # The nextExecutionAt property
+    next_execution_at: Optional[datetime.datetime] = None
+    # The nextRetryAt property
+    next_retry_at: Optional[datetime.datetime] = None
+    # The retryCount property
+    retry_count: Optional[int] = None
+    # The skipReasonCode property
+    skip_reason_code: Optional[str] = None
+    # The skipReasonDisplay property
+    skip_reason_display: Optional[str] = None
+    # The sourceEventId property
+    source_event_id: Optional[str] = None
+    # The startedAt property
+    started_at: Optional[datetime.datetime] = None
+    # The status property
+    status: Optional[str] = None
+    # The statusDisplay property
+    status_display: Optional[str] = None
+    # The triggerDisplay property
+    trigger_display: Optional[str] = None
+    # The triggerType property
+    trigger_type: Optional[str] = None
+    # The updatedAt property
+    updated_at: Optional[datetime.datetime] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationWorkflowRunResponse:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: AutomationWorkflowRunResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationWorkflowRunResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .automation_workflow_action_response import AutomationWorkflowActionResponse
+        from .automation_workflow_event_response import AutomationWorkflowEventResponse
+
+        from .automation_workflow_action_response import AutomationWorkflowActionResponse
+        from .automation_workflow_event_response import AutomationWorkflowEventResponse
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "actions": lambda n : setattr(self, 'actions', n.get_collection_of_object_values(AutomationWorkflowActionResponse)),
+            "automationId": lambda n : setattr(self, 'automation_id', n.get_str_value()),
+            "automationName": lambda n : setattr(self, 'automation_name', n.get_str_value()),
+            "businessId": lambda n : setattr(self, 'business_id', n.get_str_value()),
+            "cancelledAt": lambda n : setattr(self, 'cancelled_at', n.get_datetime_value()),
+            "completedAt": lambda n : setattr(self, 'completed_at', n.get_datetime_value()),
+            "correlationId": lambda n : setattr(self, 'correlation_id', n.get_str_value()),
+            "currentStepId": lambda n : setattr(self, 'current_step_id', n.get_str_value()),
+            "currentStepName": lambda n : setattr(self, 'current_step_name', n.get_str_value()),
+            "events": lambda n : setattr(self, 'events', n.get_collection_of_object_values(AutomationWorkflowEventResponse)),
+            "executionKey": lambda n : setattr(self, 'execution_key', n.get_str_value()),
+            "failedAt": lambda n : setattr(self, 'failed_at', n.get_datetime_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "internalErrorDetails": lambda n : setattr(self, 'internal_error_details', n.get_str_value()),
+            "lastActionSummary": lambda n : setattr(self, 'last_action_summary', n.get_str_value()),
+            "lastErrorCode": lambda n : setattr(self, 'last_error_code', n.get_str_value()),
+            "lastErrorMessage": lambda n : setattr(self, 'last_error_message', n.get_str_value()),
+            "lastExecutionAt": lambda n : setattr(self, 'last_execution_at', n.get_datetime_value()),
+            "leadId": lambda n : setattr(self, 'lead_id', n.get_str_value()),
+            "maxRetryCount": lambda n : setattr(self, 'max_retry_count', n.get_int_value()),
+            "nextExecutionAt": lambda n : setattr(self, 'next_execution_at', n.get_datetime_value()),
+            "nextRetryAt": lambda n : setattr(self, 'next_retry_at', n.get_datetime_value()),
+            "retryCount": lambda n : setattr(self, 'retry_count', n.get_int_value()),
+            "skipReasonCode": lambda n : setattr(self, 'skip_reason_code', n.get_str_value()),
+            "skipReasonDisplay": lambda n : setattr(self, 'skip_reason_display', n.get_str_value()),
+            "sourceEventId": lambda n : setattr(self, 'source_event_id', n.get_str_value()),
+            "startedAt": lambda n : setattr(self, 'started_at', n.get_datetime_value()),
+            "status": lambda n : setattr(self, 'status', n.get_str_value()),
+            "statusDisplay": lambda n : setattr(self, 'status_display', n.get_str_value()),
+            "triggerDisplay": lambda n : setattr(self, 'trigger_display', n.get_str_value()),
+            "triggerType": lambda n : setattr(self, 'trigger_type', n.get_str_value()),
+            "updatedAt": lambda n : setattr(self, 'updated_at', n.get_datetime_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_collection_of_object_values("actions", self.actions)
+        writer.write_str_value("automationId", self.automation_id)
+        writer.write_str_value("automationName", self.automation_name)
+        writer.write_str_value("businessId", self.business_id)
+        writer.write_datetime_value("cancelledAt", self.cancelled_at)
+        writer.write_datetime_value("completedAt", self.completed_at)
+        writer.write_str_value("correlationId", self.correlation_id)
+        writer.write_str_value("currentStepId", self.current_step_id)
+        writer.write_str_value("currentStepName", self.current_step_name)
+        writer.write_collection_of_object_values("events", self.events)
+        writer.write_str_value("executionKey", self.execution_key)
+        writer.write_datetime_value("failedAt", self.failed_at)
+        writer.write_str_value("id", self.id)
+        writer.write_str_value("internalErrorDetails", self.internal_error_details)
+        writer.write_str_value("lastActionSummary", self.last_action_summary)
+        writer.write_str_value("lastErrorCode", self.last_error_code)
+        writer.write_str_value("lastErrorMessage", self.last_error_message)
+        writer.write_datetime_value("lastExecutionAt", self.last_execution_at)
+        writer.write_str_value("leadId", self.lead_id)
+        writer.write_int_value("maxRetryCount", self.max_retry_count)
+        writer.write_datetime_value("nextExecutionAt", self.next_execution_at)
+        writer.write_datetime_value("nextRetryAt", self.next_retry_at)
+        writer.write_int_value("retryCount", self.retry_count)
+        writer.write_str_value("skipReasonCode", self.skip_reason_code)
+        writer.write_str_value("skipReasonDisplay", self.skip_reason_display)
+        writer.write_str_value("sourceEventId", self.source_event_id)
+        writer.write_datetime_value("startedAt", self.started_at)
+        writer.write_str_value("status", self.status)
+        writer.write_str_value("statusDisplay", self.status_display)
+        writer.write_str_value("triggerDisplay", self.trigger_display)
+        writer.write_str_value("triggerType", self.trigger_type)
+        writer.write_datetime_value("updatedAt", self.updated_at)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_workflow_status_response.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .automation_workflow_run_response import AutomationWorkflowRunResponse
+
+@dataclass
+class AutomationWorkflowStatusResponse(AdditionalDataHolder, Parsable):
+    """
+    Automation workflow status collection for a lead.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The leadId property
+    lead_id: Optional[str] = None
+    # The runs property
+    runs: Optional[list[AutomationWorkflowRunResponse]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationWorkflowStatusResponse:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: AutomationWorkflowStatusResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationWorkflowStatusResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .automation_workflow_run_response import AutomationWorkflowRunResponse
+
+        from .automation_workflow_run_response import AutomationWorkflowRunResponse
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "leadId": lambda n : setattr(self, 'lead_id', n.get_str_value()),
+            "runs": lambda n : setattr(self, 'runs', n.get_collection_of_object_values(AutomationWorkflowRunResponse)),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("leadId", self.lead_id)
+        writer.write_collection_of_object_values("runs", self.runs)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/billable_unit.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class BillableUnit(str, Enum):
+    Sms_segment = "sms_segment",
+    Mms_message = "mms_message",
+    Email_message = "email_message",
+    Voice_minute = "voice_minute",
+    Phone_number_month = "phone_number_month",
+    Warmup_sms_segment = "warmup_sms_segment",
+    Warmup_voice_minute = "warmup_voice_minute",
+    Website_setup = "website_setup",
+    Domain_registration = "domain_registration",
+    OneZerodlc_application = "10dlc_application",
+    Connection_action = "connection_action",
+    Automation_run = "automation_run",
+

leadping/models/billing_plan.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+class BillingPlan(str, Enum):
+    Annual = "Annual",
+    Monthly = "Monthly",
+