leadping 1.0.0__py3-none-any.whl

leadping/models/disposition_response.py

@@ -0,0 +1,169 @@
+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 .disposition_response_category import DispositionResponse_category
+    from .disposition_response_change_source import DispositionResponse_changeSource
+
+@dataclass
+class DispositionResponse(AdditionalDataHolder, Parsable):
+    """
+    Response model for disposition 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 date and time for the appointment end at value on this disposition.
+    appointment_end_at: Optional[datetime.datetime] = None
+    # The appointment notes value for this disposition.
+    appointment_notes: Optional[str] = None
+    # The date and time for the appointment start at value on this disposition.
+    appointment_start_at: Optional[datetime.datetime] = None
+    # The assigned to user ID associated with this disposition.
+    assigned_to_user_id: Optional[str] = None
+    # The date and time for the callback at value on this disposition.
+    callback_at: Optional[datetime.datetime] = None
+    # Controlled disposition categories used for reporting, automation, and analytics.
+    category: Optional[DispositionResponse_category] = None
+    # Known sources that can change a lead's current disposition.
+    change_source: Optional[DispositionResponse_changeSource] = None
+    # The changedAt property
+    changed_at: Optional[datetime.datetime] = None
+    # The changedByAutomationId property
+    changed_by_automation_id: Optional[str] = None
+    # The changedByUserId property
+    changed_by_user_id: Optional[str] = None
+    # The date and time for the created at value on this disposition.
+    created_at: Optional[datetime.datetime] = None
+    # The current follow up status for this disposition.
+    follow_up_status: Optional[str] = None
+    # The unique ID for this disposition.
+    id: Optional[str] = None
+    # Whether this disposition is missed call follow up.
+    is_missed_call_follow_up: Optional[bool] = None
+    # The lead ID associated with this disposition.
+    lead_id: Optional[str] = None
+    # The newDispositionId property
+    new_disposition_id: Optional[str] = None
+    # The operator or customer notes recorded for this disposition.
+    notes: Optional[str] = None
+    # The oldDispositionId property
+    old_disposition_id: Optional[str] = None
+    # The oldDispositionOutcome property
+    old_disposition_outcome: Optional[str] = None
+    # The oldDispositionType property
+    old_disposition_type: Optional[str] = None
+    # The outcome value for this disposition.
+    outcome: Optional[str] = None
+    # The reason this disposition was changed.
+    reason: Optional[str] = None
+    # The related call event ID associated with this disposition.
+    related_call_event_id: Optional[str] = None
+    # The source ID associated with this disposition.
+    source_id: Optional[str] = None
+    # The date and time for the task due at value on this disposition.
+    task_due_at: Optional[datetime.datetime] = None
+    # The date and time for the timestamp value on this disposition.
+    timestamp: Optional[datetime.datetime] = None
+    # The type classification for this disposition.
+    type: Optional[str] = None
+    # The date and time for the updated at value on this disposition.
+    updated_at: Optional[datetime.datetime] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> DispositionResponse:
+        """
+        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: DispositionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return DispositionResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .disposition_response_category import DispositionResponse_category
+        from .disposition_response_change_source import DispositionResponse_changeSource
+
+        from .disposition_response_category import DispositionResponse_category
+        from .disposition_response_change_source import DispositionResponse_changeSource
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "appointmentEndAt": lambda n : setattr(self, 'appointment_end_at', n.get_datetime_value()),
+            "appointmentNotes": lambda n : setattr(self, 'appointment_notes', n.get_str_value()),
+            "appointmentStartAt": lambda n : setattr(self, 'appointment_start_at', n.get_datetime_value()),
+            "assignedToUserId": lambda n : setattr(self, 'assigned_to_user_id', n.get_str_value()),
+            "callbackAt": lambda n : setattr(self, 'callback_at', n.get_datetime_value()),
+            "category": lambda n : setattr(self, 'category', n.get_enum_value(DispositionResponse_category)),
+            "changeSource": lambda n : setattr(self, 'change_source', n.get_enum_value(DispositionResponse_changeSource)),
+            "changedAt": lambda n : setattr(self, 'changed_at', n.get_datetime_value()),
+            "changedByAutomationId": lambda n : setattr(self, 'changed_by_automation_id', n.get_str_value()),
+            "changedByUserId": lambda n : setattr(self, 'changed_by_user_id', n.get_str_value()),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "followUpStatus": lambda n : setattr(self, 'follow_up_status', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isMissedCallFollowUp": lambda n : setattr(self, 'is_missed_call_follow_up', n.get_bool_value()),
+            "leadId": lambda n : setattr(self, 'lead_id', n.get_str_value()),
+            "newDispositionId": lambda n : setattr(self, 'new_disposition_id', n.get_str_value()),
+            "notes": lambda n : setattr(self, 'notes', n.get_str_value()),
+            "oldDispositionId": lambda n : setattr(self, 'old_disposition_id', n.get_str_value()),
+            "oldDispositionOutcome": lambda n : setattr(self, 'old_disposition_outcome', n.get_str_value()),
+            "oldDispositionType": lambda n : setattr(self, 'old_disposition_type', n.get_str_value()),
+            "outcome": lambda n : setattr(self, 'outcome', n.get_str_value()),
+            "reason": lambda n : setattr(self, 'reason', n.get_str_value()),
+            "relatedCallEventId": lambda n : setattr(self, 'related_call_event_id', n.get_str_value()),
+            "sourceId": lambda n : setattr(self, 'source_id', n.get_str_value()),
+            "taskDueAt": lambda n : setattr(self, 'task_due_at', n.get_datetime_value()),
+            "timestamp": lambda n : setattr(self, 'timestamp', n.get_datetime_value()),
+            "type": lambda n : setattr(self, '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_datetime_value("appointmentEndAt", self.appointment_end_at)
+        writer.write_str_value("appointmentNotes", self.appointment_notes)
+        writer.write_datetime_value("appointmentStartAt", self.appointment_start_at)
+        writer.write_str_value("assignedToUserId", self.assigned_to_user_id)
+        writer.write_datetime_value("callbackAt", self.callback_at)
+        writer.write_enum_value("category", self.category)
+        writer.write_enum_value("changeSource", self.change_source)
+        writer.write_datetime_value("changedAt", self.changed_at)
+        writer.write_str_value("changedByAutomationId", self.changed_by_automation_id)
+        writer.write_str_value("changedByUserId", self.changed_by_user_id)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_str_value("followUpStatus", self.follow_up_status)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isMissedCallFollowUp", self.is_missed_call_follow_up)
+        writer.write_str_value("leadId", self.lead_id)
+        writer.write_str_value("newDispositionId", self.new_disposition_id)
+        writer.write_str_value("notes", self.notes)
+        writer.write_str_value("oldDispositionId", self.old_disposition_id)
+        writer.write_str_value("oldDispositionOutcome", self.old_disposition_outcome)
+        writer.write_str_value("oldDispositionType", self.old_disposition_type)
+        writer.write_str_value("outcome", self.outcome)
+        writer.write_str_value("reason", self.reason)
+        writer.write_str_value("relatedCallEventId", self.related_call_event_id)
+        writer.write_str_value("sourceId", self.source_id)
+        writer.write_datetime_value("taskDueAt", self.task_due_at)
+        writer.write_datetime_value("timestamp", self.timestamp)
+        writer.write_str_value("type", self.type)
+        writer.write_datetime_value("updatedAt", self.updated_at)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/disposition_response_category.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class DispositionResponse_category(str, Enum):
+    Open = "Open",
+    Qualified = "Qualified",
+    Converted = "Converted",
+    Lost = "Lost",
+    Invalid = "Invalid",
+    Duplicate = "Duplicate",
+

leadping/models/disposition_response_change_source.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class DispositionResponse_changeSource(str, Enum):
+    User = "User",
+    AI = "AI",
+    Automation = "Automation",
+    System = "System",
+    API = "API",
+

leadping/models/eligible_outgoing_number_response.py

@@ -0,0 +1,112 @@
+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 .eligible_outgoing_number_response_health_status import EligibleOutgoingNumberResponse_healthStatus
+    from .outgoing_number_selection_reason import OutgoingNumberSelectionReason
+
+@dataclass
+class EligibleOutgoingNumberResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing eligible outgoing number 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 campaign ID associated with this eligible outgoing number.
+    campaign_id: Optional[str] = None
+    # Whether the caller can send this eligible outgoing number.
+    can_send: Optional[bool] = None
+    # The display number value for this eligible outgoing number.
+    display_number: Optional[str] = None
+    # The health label value for this eligible outgoing number.
+    health_label: Optional[str] = None
+    # Defines the supported SMS Warmup Health State values.
+    health_status: Optional[EligibleOutgoingNumberResponse_healthStatus] = None
+    # The health warning value for this eligible outgoing number.
+    health_warning: Optional[str] = None
+    # Whether this eligible outgoing number is selected.
+    is_selected: Optional[bool] = None
+    # The human-readable label shown for this eligible outgoing number.
+    label: Optional[str] = None
+    # The number value for this eligible outgoing number.
+    number: Optional[str] = None
+    # The phone number ID associated with this eligible outgoing number.
+    phone_number_id: Optional[str] = None
+    # The reason label value for this eligible outgoing number.
+    reason_label: Optional[str] = None
+    # The human-readable selection reason explaining this eligible outgoing number.
+    selection_reason: Optional[OutgoingNumberSelectionReason] = None
+    # The source ID associated with this eligible outgoing number.
+    source_id: Optional[str] = None
+    # The team ID associated with this eligible outgoing number.
+    team_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EligibleOutgoingNumberResponse:
+        """
+        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: EligibleOutgoingNumberResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EligibleOutgoingNumberResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .eligible_outgoing_number_response_health_status import EligibleOutgoingNumberResponse_healthStatus
+        from .outgoing_number_selection_reason import OutgoingNumberSelectionReason
+
+        from .eligible_outgoing_number_response_health_status import EligibleOutgoingNumberResponse_healthStatus
+        from .outgoing_number_selection_reason import OutgoingNumberSelectionReason
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "campaignId": lambda n : setattr(self, 'campaign_id', n.get_str_value()),
+            "canSend": lambda n : setattr(self, 'can_send', n.get_bool_value()),
+            "displayNumber": lambda n : setattr(self, 'display_number', n.get_str_value()),
+            "healthLabel": lambda n : setattr(self, 'health_label', n.get_str_value()),
+            "healthStatus": lambda n : setattr(self, 'health_status', n.get_enum_value(EligibleOutgoingNumberResponse_healthStatus)),
+            "healthWarning": lambda n : setattr(self, 'health_warning', n.get_str_value()),
+            "isSelected": lambda n : setattr(self, 'is_selected', n.get_bool_value()),
+            "label": lambda n : setattr(self, 'label', n.get_str_value()),
+            "number": lambda n : setattr(self, 'number', n.get_str_value()),
+            "phoneNumberId": lambda n : setattr(self, 'phone_number_id', n.get_str_value()),
+            "reasonLabel": lambda n : setattr(self, 'reason_label', n.get_str_value()),
+            "selectionReason": lambda n : setattr(self, 'selection_reason', n.get_enum_value(OutgoingNumberSelectionReason)),
+            "sourceId": lambda n : setattr(self, 'source_id', n.get_str_value()),
+            "teamId": lambda n : setattr(self, 'team_id', 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("campaignId", self.campaign_id)
+        writer.write_bool_value("canSend", self.can_send)
+        writer.write_str_value("displayNumber", self.display_number)
+        writer.write_str_value("healthLabel", self.health_label)
+        writer.write_enum_value("healthStatus", self.health_status)
+        writer.write_str_value("healthWarning", self.health_warning)
+        writer.write_bool_value("isSelected", self.is_selected)
+        writer.write_str_value("label", self.label)
+        writer.write_str_value("number", self.number)
+        writer.write_str_value("phoneNumberId", self.phone_number_id)
+        writer.write_str_value("reasonLabel", self.reason_label)
+        writer.write_enum_value("selectionReason", self.selection_reason)
+        writer.write_str_value("sourceId", self.source_id)
+        writer.write_str_value("teamId", self.team_id)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/eligible_outgoing_number_response_health_status.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class EligibleOutgoingNumberResponse_healthStatus(str, Enum):
+    NotStarted = "Not Started",
+    Warming = "Warming",
+    Healthy = "Healthy",
+    NeedsAttention = "Needs Attention",
+    Paused = "Paused",
+    Blocked = "Blocked",
+    Ready = "Ready",
+

leadping/models/event_detail_response.py

@@ -0,0 +1,188 @@
+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 .event_detail_response_status import EventDetailResponse_status
+    from .event_detail_response_timeline_type import EventDetailResponse_timelineType
+    from .event_detail_response_user import EventDetailResponse_user
+
+@dataclass
+class EventDetailResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing event detail 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 blockedAt property
+    blocked_at: Optional[datetime.datetime] = None
+    # The canceledAt property
+    canceled_at: Optional[datetime.datetime] = None
+    # The conversationId property
+    conversation_id: Optional[str] = None
+    # The date and time when the entity was created.
+    created_at: Optional[datetime.datetime] = None
+    # The deliveredAt property
+    delivered_at: Optional[datetime.datetime] = None
+    # The human-readable description of this event detail.
+    description: Optional[str] = None
+    # The direction property
+    direction: Optional[str] = None
+    # The eventCategory property
+    event_category: Optional[str] = None
+    # The event type classification for this event detail.
+    event_type: Optional[str] = None
+    # The failedAt property
+    failed_at: Optional[datetime.datetime] = None
+    # The fromPhoneNumber property
+    from_phone_number: Optional[str] = None
+    # The fromPhoneNumberId property
+    from_phone_number_id: Optional[str] = None
+    # The unique identifier for the entity.
+    id: Optional[str] = None
+    # The lead ID associated with this event detail.
+    lead_id: Optional[str] = None
+    # The date and time when the entity was last modified, if applicable.
+    modified_at: Optional[datetime.datetime] = None
+    # The outboundPhoneNumberId property
+    outbound_phone_number_id: Optional[str] = None
+    # The providerMessageId property
+    provider_message_id: Optional[str] = None
+    # The queuedAt property
+    queued_at: Optional[datetime.datetime] = None
+    # The receivedAt property
+    received_at: Optional[datetime.datetime] = None
+    # The scheduledFor property
+    scheduled_for: Optional[datetime.datetime] = None
+    # The secondary event type classification for this event detail.
+    secondary_event_type: Optional[str] = None
+    # The sendingStartedAt property
+    sending_started_at: Optional[datetime.datetime] = None
+    # The sentAt property
+    sent_at: Optional[datetime.datetime] = None
+    # Defines the supported Event status values.
+    status: Optional[EventDetailResponse_status] = None
+    # The statusReason property
+    status_reason: Optional[str] = None
+    # The summary property
+    summary: Optional[str] = None
+    # The timelineCategory property
+    timeline_category: Optional[str] = None
+    # Defines the supported Event timeline type values.
+    timeline_type: Optional[EventDetailResponse_timelineType] = None
+    # The toPhoneNumber property
+    to_phone_number: Optional[str] = None
+    # The undeliverableAt property
+    undeliverable_at: Optional[datetime.datetime] = None
+    # A minimal Record type with an (string), (string), and maximum JSON compatibility. The reason for this type (over something like KeyValuePair, dictionary) is because of JSON serialization support.
+    user: Optional[EventDetailResponse_user] = None
+    # The user ID associated with this event detail.
+    user_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EventDetailResponse:
+        """
+        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: EventDetailResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EventDetailResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .event_detail_response_status import EventDetailResponse_status
+        from .event_detail_response_timeline_type import EventDetailResponse_timelineType
+        from .event_detail_response_user import EventDetailResponse_user
+
+        from .event_detail_response_status import EventDetailResponse_status
+        from .event_detail_response_timeline_type import EventDetailResponse_timelineType
+        from .event_detail_response_user import EventDetailResponse_user
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "blockedAt": lambda n : setattr(self, 'blocked_at', n.get_datetime_value()),
+            "canceledAt": lambda n : setattr(self, 'canceled_at', n.get_datetime_value()),
+            "conversationId": lambda n : setattr(self, 'conversation_id', n.get_str_value()),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "deliveredAt": lambda n : setattr(self, 'delivered_at', n.get_datetime_value()),
+            "description": lambda n : setattr(self, 'description', n.get_str_value()),
+            "direction": lambda n : setattr(self, 'direction', n.get_str_value()),
+            "eventCategory": lambda n : setattr(self, 'event_category', n.get_str_value()),
+            "eventType": lambda n : setattr(self, 'event_type', n.get_str_value()),
+            "failedAt": lambda n : setattr(self, 'failed_at', n.get_datetime_value()),
+            "fromPhoneNumber": lambda n : setattr(self, 'from_phone_number', n.get_str_value()),
+            "fromPhoneNumberId": lambda n : setattr(self, 'from_phone_number_id', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "leadId": lambda n : setattr(self, 'lead_id', n.get_str_value()),
+            "modifiedAt": lambda n : setattr(self, 'modified_at', n.get_datetime_value()),
+            "outboundPhoneNumberId": lambda n : setattr(self, 'outbound_phone_number_id', n.get_str_value()),
+            "providerMessageId": lambda n : setattr(self, 'provider_message_id', n.get_str_value()),
+            "queuedAt": lambda n : setattr(self, 'queued_at', n.get_datetime_value()),
+            "receivedAt": lambda n : setattr(self, 'received_at', n.get_datetime_value()),
+            "scheduledFor": lambda n : setattr(self, 'scheduled_for', n.get_datetime_value()),
+            "secondaryEventType": lambda n : setattr(self, 'secondary_event_type', n.get_str_value()),
+            "sendingStartedAt": lambda n : setattr(self, 'sending_started_at', n.get_datetime_value()),
+            "sentAt": lambda n : setattr(self, 'sent_at', n.get_datetime_value()),
+            "status": lambda n : setattr(self, 'status', n.get_enum_value(EventDetailResponse_status)),
+            "statusReason": lambda n : setattr(self, 'status_reason', n.get_str_value()),
+            "summary": lambda n : setattr(self, 'summary', n.get_str_value()),
+            "timelineCategory": lambda n : setattr(self, 'timeline_category', n.get_str_value()),
+            "timelineType": lambda n : setattr(self, 'timeline_type', n.get_enum_value(EventDetailResponse_timelineType)),
+            "toPhoneNumber": lambda n : setattr(self, 'to_phone_number', n.get_str_value()),
+            "undeliverableAt": lambda n : setattr(self, 'undeliverable_at', n.get_datetime_value()),
+            "user": lambda n : setattr(self, 'user', n.get_object_value(EventDetailResponse_user)),
+            "userId": lambda n : setattr(self, 'user_id', 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_datetime_value("blockedAt", self.blocked_at)
+        writer.write_datetime_value("canceledAt", self.canceled_at)
+        writer.write_str_value("conversationId", self.conversation_id)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_datetime_value("deliveredAt", self.delivered_at)
+        writer.write_str_value("description", self.description)
+        writer.write_str_value("direction", self.direction)
+        writer.write_str_value("eventCategory", self.event_category)
+        writer.write_str_value("eventType", self.event_type)
+        writer.write_datetime_value("failedAt", self.failed_at)
+        writer.write_str_value("fromPhoneNumber", self.from_phone_number)
+        writer.write_str_value("fromPhoneNumberId", self.from_phone_number_id)
+        writer.write_str_value("id", self.id)
+        writer.write_str_value("leadId", self.lead_id)
+        writer.write_datetime_value("modifiedAt", self.modified_at)
+        writer.write_str_value("outboundPhoneNumberId", self.outbound_phone_number_id)
+        writer.write_str_value("providerMessageId", self.provider_message_id)
+        writer.write_datetime_value("queuedAt", self.queued_at)
+        writer.write_datetime_value("receivedAt", self.received_at)
+        writer.write_datetime_value("scheduledFor", self.scheduled_for)
+        writer.write_str_value("secondaryEventType", self.secondary_event_type)
+        writer.write_datetime_value("sendingStartedAt", self.sending_started_at)
+        writer.write_datetime_value("sentAt", self.sent_at)
+        writer.write_enum_value("status", self.status)
+        writer.write_str_value("statusReason", self.status_reason)
+        writer.write_str_value("summary", self.summary)
+        writer.write_str_value("timelineCategory", self.timeline_category)
+        writer.write_enum_value("timelineType", self.timeline_type)
+        writer.write_str_value("toPhoneNumber", self.to_phone_number)
+        writer.write_datetime_value("undeliverableAt", self.undeliverable_at)
+        writer.write_object_value("user", self.user)
+        writer.write_str_value("userId", self.user_id)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/event_detail_response_status.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class EventDetailResponse_status(str, Enum):
+    Pending = "Pending",
+    InProgress = "InProgress",
+    Completed = "Completed",
+    Failed = "Failed",
+    Cancelled = "Cancelled",
+

leadping/models/event_detail_response_timeline_type.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class EventDetailResponse_timelineType(str, Enum):
+    Message = "Message",
+    Sms = "Sms",
+    Mms = "Mms",
+    Call = "Call",
+    Voicemail = "Voicemail",
+    Note = "Note",
+    Disposition = "Disposition",
+    LeadCreated = "LeadCreated",
+    LeadUpdated = "LeadUpdated",
+    Notification = "Notification",
+    Payment = "Payment",
+    Warmup = "Warmup",
+

leadping/models/event_detail_response_user.py

@@ -0,0 +1,54 @@
+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 .id_name_pair import IdNamePair
+
+from .id_name_pair import IdNamePair
+
+@dataclass
+class EventDetailResponse_user(IdNamePair, Parsable):
+    """
+    A minimal Record type with an (string), (string), and maximum JSON compatibility. The reason for this type (over something like KeyValuePair, dictionary) is because of JSON serialization support.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EventDetailResponse_user:
+        """
+        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: EventDetailResponse_user
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EventDetailResponse_user()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .id_name_pair import IdNamePair
+
+        from .id_name_pair import IdNamePair
+
+        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)
+    
+