leadping 1.0.0__py3-none-any.whl

leadping/models/analytics_trend_point_ofint.py

@@ -0,0 +1,60 @@
+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 AnalyticsTrendPointOfint(AdditionalDataHolder, Parsable):
+    # 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 endAt property
+    end_at: Optional[datetime.datetime] = None
+    # The label property
+    label: Optional[str] = None
+    # The startAt property
+    start_at: Optional[datetime.datetime] = None
+    # The value property
+    value: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AnalyticsTrendPointOfint:
+        """
+        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: AnalyticsTrendPointOfint
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AnalyticsTrendPointOfint()
+    
+    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]] = {
+            "endAt": lambda n : setattr(self, 'end_at', n.get_datetime_value()),
+            "label": lambda n : setattr(self, 'label', n.get_str_value()),
+            "startAt": lambda n : setattr(self, 'start_at', n.get_datetime_value()),
+            "value": lambda n : setattr(self, 'value', n.get_int_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_datetime_value("endAt", self.end_at)
+        writer.write_str_value("label", self.label)
+        writer.write_datetime_value("startAt", self.start_at)
+        writer.write_int_value("value", self.value)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_action.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_action_settings import AutomationAction_settings
+
+@dataclass
+class AutomationAction(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing automation action 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 unique ID for this automation action.
+    id: Optional[str] = None
+    # Whether this automation action is enabled.
+    is_enabled: Optional[bool] = None
+    # The order value for this automation action.
+    order: Optional[int] = None
+    # The settings key-value data carried with this automation action; values must be safe to expose in API responses.
+    settings: Optional[AutomationAction_settings] = None
+    # The type classification for this automation action.
+    type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationAction:
+        """
+        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: AutomationAction
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationAction()
+    
+    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_action_settings import AutomationAction_settings
+
+        from .automation_action_settings import AutomationAction_settings
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isEnabled": lambda n : setattr(self, 'is_enabled', n.get_bool_value()),
+            "order": lambda n : setattr(self, 'order', n.get_int_value()),
+            "settings": lambda n : setattr(self, 'settings', n.get_object_value(AutomationAction_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("id", self.id)
+        writer.write_bool_value("isEnabled", self.is_enabled)
+        writer.write_int_value("order", self.order)
+        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_action_run_record.py

@@ -0,0 +1,115 @@
+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 AutomationActionRunRecord(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing automation action run record 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 action ID associated with this automation action run record.
+    action_id: Optional[str] = None
+    # The action type classification for this automation action run record.
+    action_type: Optional[str] = None
+    # The automation run ID associated with this automation action run record.
+    automation_run_id: Optional[str] = None
+    # The date and time for the completed at value on this automation action run record.
+    completed_at: Optional[datetime.datetime] = None
+    # The connection key value for this automation action run record.
+    connection_key: Optional[str] = None
+    # The error value for this automation action run record.
+    error: Optional[str] = None
+    # The execution key value for this automation action run record.
+    execution_key: Optional[str] = None
+    # The date and time when this action failed.
+    failed_at: Optional[datetime.datetime] = None
+    # The failure code value for this automation action run record.
+    failure_code: Optional[str] = None
+    # The unique ID for this automation action run record.
+    id: Optional[str] = None
+    # The date and time when this action will retry, if retrying is scheduled.
+    next_retry_at: Optional[datetime.datetime] = None
+    # The order value for this automation action run record.
+    order: Optional[int] = None
+    # The output value for this automation action run record.
+    output: Optional[str] = None
+    # The processing attempts value for this automation action run record.
+    processing_attempts: Optional[int] = None
+    # The date and time when this action was scheduled to run, if it is delayed.
+    scheduled_at: Optional[datetime.datetime] = None
+    # The date and time for the started at value on this automation action run record.
+    started_at: Optional[datetime.datetime] = None
+    # The current status for this automation action run record.
+    status: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationActionRunRecord:
+        """
+        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: AutomationActionRunRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationActionRunRecord()
+    
+    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()),
+            "actionType": lambda n : setattr(self, 'action_type', n.get_str_value()),
+            "automationRunId": lambda n : setattr(self, 'automation_run_id', n.get_str_value()),
+            "completedAt": lambda n : setattr(self, 'completed_at', n.get_datetime_value()),
+            "connectionKey": lambda n : setattr(self, 'connection_key', n.get_str_value()),
+            "error": lambda n : setattr(self, 'error', n.get_str_value()),
+            "executionKey": lambda n : setattr(self, 'execution_key', n.get_str_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()),
+            "order": lambda n : setattr(self, 'order', n.get_int_value()),
+            "output": lambda n : setattr(self, 'output', n.get_str_value()),
+            "processingAttempts": lambda n : setattr(self, 'processing_attempts', n.get_int_value()),
+            "scheduledAt": lambda n : setattr(self, 'scheduled_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()),
+        }
+        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("actionType", self.action_type)
+        writer.write_str_value("automationRunId", self.automation_run_id)
+        writer.write_datetime_value("completedAt", self.completed_at)
+        writer.write_str_value("connectionKey", self.connection_key)
+        writer.write_str_value("error", self.error)
+        writer.write_str_value("executionKey", self.execution_key)
+        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("order", self.order)
+        writer.write_str_value("output", self.output)
+        writer.write_int_value("processingAttempts", self.processing_attempts)
+        writer.write_datetime_value("scheduledAt", self.scheduled_at)
+        writer.write_datetime_value("startedAt", self.started_at)
+        writer.write_str_value("status", self.status)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_action_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 AutomationAction_settings(AdditionalDataHolder, Parsable):
+    """
+    The settings key-value data carried with this automation action; 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) -> AutomationAction_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: AutomationAction_settings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationAction_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_condition.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_condition_settings import AutomationCondition_settings
+
+@dataclass
+class AutomationCondition(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing automation condition 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 unique ID for this automation condition.
+    id: Optional[str] = None
+    # Whether this automation condition is enabled.
+    is_enabled: Optional[bool] = None
+    # The operator value for this automation condition.
+    operator: Optional[str] = None
+    # The settings key-value data carried with this automation condition; values must be safe to expose in API responses.
+    settings: Optional[AutomationCondition_settings] = None
+    # The type classification for this automation condition.
+    type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationCondition:
+        """
+        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: AutomationCondition
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationCondition()
+    
+    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_condition_settings import AutomationCondition_settings
+
+        from .automation_condition_settings import AutomationCondition_settings
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isEnabled": lambda n : setattr(self, 'is_enabled', n.get_bool_value()),
+            "operator": lambda n : setattr(self, 'operator', n.get_str_value()),
+            "settings": lambda n : setattr(self, 'settings', n.get_object_value(AutomationCondition_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("id", self.id)
+        writer.write_bool_value("isEnabled", self.is_enabled)
+        writer.write_str_value("operator", self.operator)
+        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_condition_group.py

@@ -0,0 +1,65 @@
+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_condition import AutomationCondition
+
+@dataclass
+class AutomationConditionGroup(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing automation condition group 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 conditions included with this automation condition group.
+    conditions: Optional[list[AutomationCondition]] = None
+    # The unique ID for this automation condition group.
+    id: Optional[str] = None
+    # The mode value for this automation condition group.
+    mode: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationConditionGroup:
+        """
+        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: AutomationConditionGroup
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationConditionGroup()
+    
+    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_condition import AutomationCondition
+
+        from .automation_condition import AutomationCondition
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "conditions": lambda n : setattr(self, 'conditions', n.get_collection_of_object_values(AutomationCondition)),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "mode": lambda n : setattr(self, 'mode', 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_collection_of_object_values("conditions", self.conditions)
+        writer.write_str_value("id", self.id)
+        writer.write_str_value("mode", self.mode)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_condition_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 AutomationCondition_settings(AdditionalDataHolder, Parsable):
+    """
+    The settings key-value data carried with this automation condition; 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) -> AutomationCondition_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: AutomationCondition_settings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationCondition_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_preview_action_result.py

@@ -0,0 +1,66 @@
+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 AutomationPreviewActionResult(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing automation preview action 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 action ID associated with this automation preview action result.
+    action_id: Optional[str] = None
+    # The rendered output value for this automation preview action result.
+    rendered_output: Optional[str] = None
+    # The summary value for this automation preview action result.
+    summary: Optional[str] = None
+    # The warnings included with this automation preview action result.
+    warnings: Optional[list[str]] = None
+    # Whether this automation preview action result would have side effect.
+    would_have_side_effect: Optional[bool] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationPreviewActionResult:
+        """
+        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: AutomationPreviewActionResult
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationPreviewActionResult()
+    
+    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()),
+            "renderedOutput": lambda n : setattr(self, 'rendered_output', n.get_str_value()),
+            "summary": lambda n : setattr(self, 'summary', n.get_str_value()),
+            "warnings": lambda n : setattr(self, 'warnings', n.get_collection_of_primitive_values(str)),
+            "wouldHaveSideEffect": lambda n : setattr(self, 'would_have_side_effect', n.get_bool_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("renderedOutput", self.rendered_output)
+        writer.write_str_value("summary", self.summary)
+        writer.write_collection_of_primitive_values("warnings", self.warnings)
+        writer.write_bool_value("wouldHaveSideEffect", self.would_have_side_effect)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_preview_condition_result.py

@@ -0,0 +1,58 @@
+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 AutomationPreviewConditionResult(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing automation preview condition 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 condition ID associated with this automation preview condition result.
+    condition_id: Optional[str] = None
+    # Whether this automation preview condition result is passed.
+    passed: Optional[bool] = None
+    # The summary value for this automation preview condition result.
+    summary: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationPreviewConditionResult:
+        """
+        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: AutomationPreviewConditionResult
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationPreviewConditionResult()
+    
+    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]] = {
+            "conditionId": lambda n : setattr(self, 'condition_id', n.get_str_value()),
+            "passed": lambda n : setattr(self, 'passed', n.get_bool_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("conditionId", self.condition_id)
+        writer.write_bool_value("passed", self.passed)
+        writer.write_str_value("summary", self.summary)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_preview_request.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_request_snapshot import AutomationRequestSnapshot
+
+@dataclass
+class AutomationPreviewRequest(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing automation preview 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 automation value for this automation preview.
+    automation: Optional[AutomationRequestSnapshot] = None
+    # The trigger type classification for this automation preview.
+    trigger_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationPreviewRequest:
+        """
+        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: AutomationPreviewRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationPreviewRequest()
+    
+    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_request_snapshot import AutomationRequestSnapshot
+
+        from .automation_request_snapshot import AutomationRequestSnapshot
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "automation": lambda n : setattr(self, 'automation', n.get_object_value(AutomationRequestSnapshot)),
+            "triggerType": lambda n : setattr(self, 'trigger_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_object_value("automation", self.automation)
+        writer.write_str_value("triggerType", self.trigger_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+