leadping 1.0.0__py3-none-any.whl

leadping/models/automation_preview_response.py

@@ -0,0 +1,86 @@
+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_preview_action_result import AutomationPreviewActionResult
+    from .automation_preview_condition_result import AutomationPreviewConditionResult
+    from .automation_preview_response_sample_payload import AutomationPreviewResponse_samplePayload
+    from .automation_validation_result import AutomationValidationResult
+
+@dataclass
+class AutomationPreviewResponse(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing automation preview response data.
+    """
+    # 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 results included with this automation preview.
+    action_results: Optional[list[AutomationPreviewActionResult]] = None
+    # The condition results included with this automation preview.
+    condition_results: Optional[list[AutomationPreviewConditionResult]] = None
+    # The sample payload key-value data carried with this automation preview; values must be safe to expose in API responses.
+    sample_payload: Optional[AutomationPreviewResponse_samplePayload] = None
+    # The trigger type classification for this automation preview.
+    trigger_type: Optional[str] = None
+    # The validation value for this automation preview.
+    validation: Optional[AutomationValidationResult] = None
+    # The warnings included with this automation preview.
+    warnings: Optional[list[str]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationPreviewResponse:
+        """
+        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: AutomationPreviewResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationPreviewResponse()
+    
+    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_preview_action_result import AutomationPreviewActionResult
+        from .automation_preview_condition_result import AutomationPreviewConditionResult
+        from .automation_preview_response_sample_payload import AutomationPreviewResponse_samplePayload
+        from .automation_validation_result import AutomationValidationResult
+
+        from .automation_preview_action_result import AutomationPreviewActionResult
+        from .automation_preview_condition_result import AutomationPreviewConditionResult
+        from .automation_preview_response_sample_payload import AutomationPreviewResponse_samplePayload
+        from .automation_validation_result import AutomationValidationResult
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "actionResults": lambda n : setattr(self, 'action_results', n.get_collection_of_object_values(AutomationPreviewActionResult)),
+            "conditionResults": lambda n : setattr(self, 'condition_results', n.get_collection_of_object_values(AutomationPreviewConditionResult)),
+            "samplePayload": lambda n : setattr(self, 'sample_payload', n.get_object_value(AutomationPreviewResponse_samplePayload)),
+            "triggerType": lambda n : setattr(self, 'trigger_type', n.get_str_value()),
+            "validation": lambda n : setattr(self, 'validation', n.get_object_value(AutomationValidationResult)),
+            "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_object_values("actionResults", self.action_results)
+        writer.write_collection_of_object_values("conditionResults", self.condition_results)
+        writer.write_object_value("samplePayload", self.sample_payload)
+        writer.write_str_value("triggerType", self.trigger_type)
+        writer.write_object_value("validation", self.validation)
+        writer.write_collection_of_primitive_values("warnings", self.warnings)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_preview_response_sample_payload.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 AutomationPreviewResponse_samplePayload(AdditionalDataHolder, Parsable):
+    """
+    The sample payload key-value data carried with this automation preview; 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) -> AutomationPreviewResponse_samplePayload:
+        """
+        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: AutomationPreviewResponse_samplePayload
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationPreviewResponse_samplePayload()
+    
+    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_request.py

@@ -0,0 +1,122 @@
+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 import AutomationAction
+    from .automation_condition_group import AutomationConditionGroup
+    from .automation_request_admin_enablement_override import AutomationRequest_adminEnablementOverride
+    from .automation_trigger import AutomationTrigger
+
+@dataclass
+class AutomationRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for automation.
+    """
+    # 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 included with this automation.
+    actions: Optional[list[AutomationAction]] = None
+    # The adminEnablementOverride property
+    admin_enablement_override: Optional[AutomationRequest_adminEnablementOverride] = None
+    # The business ID associated with this automation.
+    business_id: Optional[str] = None
+    # The condition groups included with this automation.
+    condition_groups: Optional[list[AutomationConditionGroup]] = None
+    # The created by user ID associated with this automation.
+    created_by_user_id: Optional[str] = None
+    # The human-readable description of this automation.
+    description: Optional[str] = None
+    # Whether this automation is enabled.
+    enabled: Optional[bool] = None
+    # The unique identifier for the entity, when updating an existing entity.
+    id: Optional[str] = None
+    # Whether this automation is system managed.
+    is_system_managed: Optional[bool] = None
+    # The management level value for this automation.
+    management_level: Optional[str] = None
+    # The display name for the entity.
+    name: Optional[str] = None
+    # The scope value for this automation.
+    scope: Optional[str] = None
+    # The triggers included with this automation.
+    triggers: Optional[list[AutomationTrigger]] = None
+    # The version value for this automation.
+    version: Optional[int] = None
+    # The visibility value for this automation.
+    visibility: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationRequest:
+        """
+        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: AutomationRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationRequest()
+    
+    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 import AutomationAction
+        from .automation_condition_group import AutomationConditionGroup
+        from .automation_request_admin_enablement_override import AutomationRequest_adminEnablementOverride
+        from .automation_trigger import AutomationTrigger
+
+        from .automation_action import AutomationAction
+        from .automation_condition_group import AutomationConditionGroup
+        from .automation_request_admin_enablement_override import AutomationRequest_adminEnablementOverride
+        from .automation_trigger import AutomationTrigger
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "actions": lambda n : setattr(self, 'actions', n.get_collection_of_object_values(AutomationAction)),
+            "adminEnablementOverride": lambda n : setattr(self, 'admin_enablement_override', n.get_object_value(AutomationRequest_adminEnablementOverride)),
+            "businessId": lambda n : setattr(self, 'business_id', n.get_str_value()),
+            "conditionGroups": lambda n : setattr(self, 'condition_groups', n.get_collection_of_object_values(AutomationConditionGroup)),
+            "createdByUserId": lambda n : setattr(self, 'created_by_user_id', n.get_str_value()),
+            "description": lambda n : setattr(self, 'description', n.get_str_value()),
+            "enabled": lambda n : setattr(self, 'enabled', n.get_bool_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isSystemManaged": lambda n : setattr(self, 'is_system_managed', n.get_bool_value()),
+            "managementLevel": lambda n : setattr(self, 'management_level', n.get_str_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "scope": lambda n : setattr(self, 'scope', n.get_str_value()),
+            "triggers": lambda n : setattr(self, 'triggers', n.get_collection_of_object_values(AutomationTrigger)),
+            "version": lambda n : setattr(self, 'version', n.get_int_value()),
+            "visibility": lambda n : setattr(self, 'visibility', 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("actions", self.actions)
+        writer.write_object_value("adminEnablementOverride", self.admin_enablement_override)
+        writer.write_str_value("businessId", self.business_id)
+        writer.write_collection_of_object_values("conditionGroups", self.condition_groups)
+        writer.write_str_value("createdByUserId", self.created_by_user_id)
+        writer.write_str_value("description", self.description)
+        writer.write_bool_value("enabled", self.enabled)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isSystemManaged", self.is_system_managed)
+        writer.write_str_value("managementLevel", self.management_level)
+        writer.write_str_value("name", self.name)
+        writer.write_str_value("scope", self.scope)
+        writer.write_collection_of_object_values("triggers", self.triggers)
+        writer.write_int_value("version", self.version)
+        writer.write_str_value("visibility", self.visibility)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_request_admin_enablement_override.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .admin_enablement_override import AdminEnablementOverride
+
+from .admin_enablement_override import AdminEnablementOverride
+
+@dataclass
+class AutomationRequest_adminEnablementOverride(AdminEnablementOverride, Parsable):
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationRequest_adminEnablementOverride:
+        """
+        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: AutomationRequest_adminEnablementOverride
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationRequest_adminEnablementOverride()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .admin_enablement_override import AdminEnablementOverride
+
+        from .admin_enablement_override import AdminEnablementOverride
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        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.")
+        super().serialize(writer)
+    
+

leadping/models/automation_request_snapshot.py

@@ -0,0 +1,111 @@
+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 import AutomationAction
+    from .automation_condition_group import AutomationConditionGroup
+    from .automation_trigger import AutomationTrigger
+
+@dataclass
+class AutomationRequestSnapshot(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing automation request snapshot 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 actions included with this automation request snapshot.
+    actions: Optional[list[AutomationAction]] = None
+    # The business ID associated with this automation request snapshot.
+    business_id: Optional[str] = None
+    # The condition groups included with this automation request snapshot.
+    condition_groups: Optional[list[AutomationConditionGroup]] = None
+    # The created by user ID associated with this automation request snapshot.
+    created_by_user_id: Optional[str] = None
+    # The human-readable description of this automation request snapshot.
+    description: Optional[str] = None
+    # Whether this automation request snapshot is enabled.
+    enabled: Optional[bool] = None
+    # The unique ID for this automation request snapshot.
+    id: Optional[str] = None
+    # Whether this automation request snapshot is system managed.
+    is_system_managed: Optional[bool] = None
+    # The management level value for this automation request snapshot.
+    management_level: Optional[str] = None
+    # The human-readable name shown for this automation request snapshot.
+    name: Optional[str] = None
+    # The scope value for this automation request snapshot.
+    scope: Optional[str] = None
+    # The triggers included with this automation request snapshot.
+    triggers: Optional[list[AutomationTrigger]] = None
+    # The visibility value for this automation request snapshot.
+    visibility: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationRequestSnapshot:
+        """
+        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: AutomationRequestSnapshot
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationRequestSnapshot()
+    
+    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 import AutomationAction
+        from .automation_condition_group import AutomationConditionGroup
+        from .automation_trigger import AutomationTrigger
+
+        from .automation_action import AutomationAction
+        from .automation_condition_group import AutomationConditionGroup
+        from .automation_trigger import AutomationTrigger
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "actions": lambda n : setattr(self, 'actions', n.get_collection_of_object_values(AutomationAction)),
+            "businessId": lambda n : setattr(self, 'business_id', n.get_str_value()),
+            "conditionGroups": lambda n : setattr(self, 'condition_groups', n.get_collection_of_object_values(AutomationConditionGroup)),
+            "createdByUserId": lambda n : setattr(self, 'created_by_user_id', n.get_str_value()),
+            "description": lambda n : setattr(self, 'description', n.get_str_value()),
+            "enabled": lambda n : setattr(self, 'enabled', n.get_bool_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isSystemManaged": lambda n : setattr(self, 'is_system_managed', n.get_bool_value()),
+            "managementLevel": lambda n : setattr(self, 'management_level', n.get_str_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "scope": lambda n : setattr(self, 'scope', n.get_str_value()),
+            "triggers": lambda n : setattr(self, 'triggers', n.get_collection_of_object_values(AutomationTrigger)),
+            "visibility": lambda n : setattr(self, 'visibility', 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("actions", self.actions)
+        writer.write_str_value("businessId", self.business_id)
+        writer.write_collection_of_object_values("conditionGroups", self.condition_groups)
+        writer.write_str_value("createdByUserId", self.created_by_user_id)
+        writer.write_str_value("description", self.description)
+        writer.write_bool_value("enabled", self.enabled)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isSystemManaged", self.is_system_managed)
+        writer.write_str_value("managementLevel", self.management_level)
+        writer.write_str_value("name", self.name)
+        writer.write_str_value("scope", self.scope)
+        writer.write_collection_of_object_values("triggers", self.triggers)
+        writer.write_str_value("visibility", self.visibility)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_response.py

@@ -0,0 +1,164 @@
+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_action import AutomationAction
+    from .automation_condition_group import AutomationConditionGroup
+    from .automation_response_admin_enablement_override import AutomationResponse_adminEnablementOverride
+    from .automation_response_business import AutomationResponse_business
+    from .automation_response_user import AutomationResponse_user
+    from .automation_run_record import AutomationRunRecord
+    from .automation_trigger import AutomationTrigger
+
+@dataclass
+class AutomationResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing automation data returned to callers.
+    """
+    # 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 included with this automation.
+    actions: Optional[list[AutomationAction]] = None
+    # The adminEnablementOverride property
+    admin_enablement_override: Optional[AutomationResponse_adminEnablementOverride] = None
+    # The business value for this automation.
+    business: Optional[AutomationResponse_business] = None
+    # The business ID associated with this automation.
+    business_id: Optional[str] = None
+    # The condition groups included with this automation.
+    condition_groups: Optional[list[AutomationConditionGroup]] = None
+    # The date and time when the entity was created.
+    created_at: Optional[datetime.datetime] = None
+    # The created by user ID associated with this automation.
+    created_by_user_id: Optional[str] = None
+    # The human-readable description of this automation.
+    description: Optional[str] = None
+    # Whether this automation is enabled.
+    enabled: Optional[bool] = None
+    # The unique identifier for the entity.
+    id: Optional[str] = None
+    # Whether this automation is system managed.
+    is_system_managed: Optional[bool] = None
+    # The date and time for the last run at value on this automation.
+    last_run_at: Optional[datetime.datetime] = None
+    # The date and time for the last run error value on this automation.
+    last_run_error: Optional[str] = None
+    # The current last run status for this automation.
+    last_run_status: Optional[str] = None
+    # The management level value for this automation.
+    management_level: Optional[str] = None
+    # The date and time when the entity was last modified, if applicable.
+    modified_at: Optional[datetime.datetime] = None
+    # The display name for the entity.
+    name: Optional[str] = None
+    # The recent runs included with this automation.
+    recent_runs: Optional[list[AutomationRunRecord]] = None
+    # The scope value for this automation.
+    scope: Optional[str] = None
+    # The triggers included with this automation.
+    triggers: Optional[list[AutomationTrigger]] = None
+    # The user value for this automation.
+    user: Optional[AutomationResponse_user] = None
+    # The version value for this automation.
+    version: Optional[int] = None
+    # The visibility value for this automation.
+    visibility: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationResponse:
+        """
+        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: AutomationResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationResponse()
+    
+    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 import AutomationAction
+        from .automation_condition_group import AutomationConditionGroup
+        from .automation_response_admin_enablement_override import AutomationResponse_adminEnablementOverride
+        from .automation_response_business import AutomationResponse_business
+        from .automation_response_user import AutomationResponse_user
+        from .automation_run_record import AutomationRunRecord
+        from .automation_trigger import AutomationTrigger
+
+        from .automation_action import AutomationAction
+        from .automation_condition_group import AutomationConditionGroup
+        from .automation_response_admin_enablement_override import AutomationResponse_adminEnablementOverride
+        from .automation_response_business import AutomationResponse_business
+        from .automation_response_user import AutomationResponse_user
+        from .automation_run_record import AutomationRunRecord
+        from .automation_trigger import AutomationTrigger
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "actions": lambda n : setattr(self, 'actions', n.get_collection_of_object_values(AutomationAction)),
+            "adminEnablementOverride": lambda n : setattr(self, 'admin_enablement_override', n.get_object_value(AutomationResponse_adminEnablementOverride)),
+            "business": lambda n : setattr(self, 'business', n.get_object_value(AutomationResponse_business)),
+            "businessId": lambda n : setattr(self, 'business_id', n.get_str_value()),
+            "conditionGroups": lambda n : setattr(self, 'condition_groups', n.get_collection_of_object_values(AutomationConditionGroup)),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "createdByUserId": lambda n : setattr(self, 'created_by_user_id', n.get_str_value()),
+            "description": lambda n : setattr(self, 'description', n.get_str_value()),
+            "enabled": lambda n : setattr(self, 'enabled', n.get_bool_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isSystemManaged": lambda n : setattr(self, 'is_system_managed', n.get_bool_value()),
+            "lastRunAt": lambda n : setattr(self, 'last_run_at', n.get_datetime_value()),
+            "lastRunError": lambda n : setattr(self, 'last_run_error', n.get_str_value()),
+            "lastRunStatus": lambda n : setattr(self, 'last_run_status', n.get_str_value()),
+            "managementLevel": lambda n : setattr(self, 'management_level', n.get_str_value()),
+            "modifiedAt": lambda n : setattr(self, 'modified_at', n.get_datetime_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "recentRuns": lambda n : setattr(self, 'recent_runs', n.get_collection_of_object_values(AutomationRunRecord)),
+            "scope": lambda n : setattr(self, 'scope', n.get_str_value()),
+            "triggers": lambda n : setattr(self, 'triggers', n.get_collection_of_object_values(AutomationTrigger)),
+            "user": lambda n : setattr(self, 'user', n.get_object_value(AutomationResponse_user)),
+            "version": lambda n : setattr(self, 'version', n.get_int_value()),
+            "visibility": lambda n : setattr(self, 'visibility', 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("actions", self.actions)
+        writer.write_object_value("adminEnablementOverride", self.admin_enablement_override)
+        writer.write_object_value("business", self.business)
+        writer.write_str_value("businessId", self.business_id)
+        writer.write_collection_of_object_values("conditionGroups", self.condition_groups)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_str_value("createdByUserId", self.created_by_user_id)
+        writer.write_str_value("description", self.description)
+        writer.write_bool_value("enabled", self.enabled)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isSystemManaged", self.is_system_managed)
+        writer.write_datetime_value("lastRunAt", self.last_run_at)
+        writer.write_str_value("lastRunError", self.last_run_error)
+        writer.write_str_value("lastRunStatus", self.last_run_status)
+        writer.write_str_value("managementLevel", self.management_level)
+        writer.write_datetime_value("modifiedAt", self.modified_at)
+        writer.write_str_value("name", self.name)
+        writer.write_collection_of_object_values("recentRuns", self.recent_runs)
+        writer.write_str_value("scope", self.scope)
+        writer.write_collection_of_object_values("triggers", self.triggers)
+        writer.write_object_value("user", self.user)
+        writer.write_int_value("version", self.version)
+        writer.write_str_value("visibility", self.visibility)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/automation_response_admin_enablement_override.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .admin_enablement_override import AdminEnablementOverride
+
+from .admin_enablement_override import AdminEnablementOverride
+
+@dataclass
+class AutomationResponse_adminEnablementOverride(AdminEnablementOverride, Parsable):
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AutomationResponse_adminEnablementOverride:
+        """
+        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: AutomationResponse_adminEnablementOverride
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AutomationResponse_adminEnablementOverride()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .admin_enablement_override import AdminEnablementOverride
+
+        from .admin_enablement_override import AdminEnablementOverride
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        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.")
+        super().serialize(writer)
+    
+