leadping 1.0.0__py3-none-any.whl

leadping/models/lead_tags_request.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 LeadTagsRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for adding or replacing tags on a lead.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # Whether missing tag names should be created for the lead's business.
+    create_missing: Optional[bool] = None
+    # Existing tag ids to apply.
+    tag_ids: Optional[list[str]] = None
+    # Tag names to apply. Missing names may be created when CreateMissing is true.
+    tag_names: Optional[list[str]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadTagsRequest:
+        """
+        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: LeadTagsRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadTagsRequest()
+    
+    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]] = {
+            "createMissing": lambda n : setattr(self, 'create_missing', n.get_bool_value()),
+            "tagIds": lambda n : setattr(self, 'tag_ids', n.get_collection_of_primitive_values(str)),
+            "tagNames": lambda n : setattr(self, 'tag_names', 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_bool_value("createMissing", self.create_missing)
+        writer.write_collection_of_primitive_values("tagIds", self.tag_ids)
+        writer.write_collection_of_primitive_values("tagNames", self.tag_names)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/mobile_device_preferences.py

@@ -0,0 +1,63 @@
+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 MobileDevicePreferences(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing Leadping mobile preferences for a single user device.
+    """
+    # 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)
+
+    # Stable device identifier generated by the Leadping mobile app.
+    device_id: Optional[str] = None
+    # Human-readable device name captured by the Leadping mobile app.
+    device_name: Optional[str] = None
+    # Whether inbound phone calls are enabled for this user device.
+    inbound_phone_calls_enabled: Optional[bool] = None
+    # The date and time this device preference was last updated.
+    updated_at: Optional[datetime.datetime] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MobileDevicePreferences:
+        """
+        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: MobileDevicePreferences
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MobileDevicePreferences()
+    
+    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]] = {
+            "deviceId": lambda n : setattr(self, 'device_id', n.get_str_value()),
+            "deviceName": lambda n : setattr(self, 'device_name', n.get_str_value()),
+            "inboundPhoneCallsEnabled": lambda n : setattr(self, 'inbound_phone_calls_enabled', n.get_bool_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_str_value("deviceId", self.device_id)
+        writer.write_str_value("deviceName", self.device_name)
+        writer.write_bool_value("inboundPhoneCallsEnabled", self.inbound_phone_calls_enabled)
+        writer.write_datetime_value("updatedAt", self.updated_at)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/notification_priority.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class NotificationPriority(str, Enum):
+    Low = "Low",
+    Medium = "Medium",
+    High = "High",
+    Critical = "Critical",
+

leadping/models/notification_table_row.py

@@ -0,0 +1,113 @@
+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 .notification_priority import NotificationPriority
+    from .notification_type import NotificationType
+
+@dataclass
+class NotificationTableRow(AdditionalDataHolder, Parsable):
+    """
+    API response containing notification 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 action button text value for this notification.
+    action_button_text: Optional[str] = None
+    # The URL associated with this notification.
+    action_url: Optional[str] = None
+    # The date and time when the entity was created.
+    created_at: Optional[datetime.datetime] = None
+    # The details value for this notification.
+    details: Optional[str] = None
+    # The unique identifier for the entity.
+    id: Optional[str] = None
+    # Whether this notification is read.
+    is_read: Optional[bool] = None
+    # The message value for this notification.
+    message: 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 priority value for this notification.
+    priority: Optional[NotificationPriority] = None
+    # The date and time for the read at value on this notification.
+    read_at: Optional[datetime.datetime] = None
+    # The related entity ID associated with this notification.
+    related_entity_id: Optional[str] = None
+    # The related entity type classification for this notification.
+    related_entity_type: Optional[str] = None
+    # The type classification for this notification.
+    type: Optional[NotificationType] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> NotificationTableRow:
+        """
+        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: NotificationTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return NotificationTableRow()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .notification_priority import NotificationPriority
+        from .notification_type import NotificationType
+
+        from .notification_priority import NotificationPriority
+        from .notification_type import NotificationType
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "actionButtonText": lambda n : setattr(self, 'action_button_text', n.get_str_value()),
+            "actionUrl": lambda n : setattr(self, 'action_url', n.get_str_value()),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "details": lambda n : setattr(self, 'details', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isRead": lambda n : setattr(self, 'is_read', n.get_bool_value()),
+            "message": lambda n : setattr(self, 'message', 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()),
+            "priority": lambda n : setattr(self, 'priority', n.get_enum_value(NotificationPriority)),
+            "readAt": lambda n : setattr(self, 'read_at', n.get_datetime_value()),
+            "relatedEntityId": lambda n : setattr(self, 'related_entity_id', n.get_str_value()),
+            "relatedEntityType": lambda n : setattr(self, 'related_entity_type', n.get_str_value()),
+            "type": lambda n : setattr(self, 'type', n.get_enum_value(NotificationType)),
+        }
+        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("actionButtonText", self.action_button_text)
+        writer.write_str_value("actionUrl", self.action_url)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_str_value("details", self.details)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isRead", self.is_read)
+        writer.write_str_value("message", self.message)
+        writer.write_datetime_value("modifiedAt", self.modified_at)
+        writer.write_str_value("name", self.name)
+        writer.write_enum_value("priority", self.priority)
+        writer.write_datetime_value("readAt", self.read_at)
+        writer.write_str_value("relatedEntityId", self.related_entity_id)
+        writer.write_str_value("relatedEntityType", self.related_entity_type)
+        writer.write_enum_value("type", self.type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/notification_type.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class NotificationType(str, Enum):
+    General = "General",
+    Lead = "Lead",
+    Call = "Call",
+    Sms = "Sms",
+    Billing = "Billing",
+    System = "System",
+    Success = "Success",
+    Warning = "Warning",
+    Error = "Error",
+    Info = "Info",
+    Announcement = "Announcement",
+    Activation = "Activation",
+

leadping/models/order_by_option.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 .order_by_option_direction import OrderByOption_direction
+
+@dataclass
+class OrderByOption(AdditionalDataHolder, Parsable):
+    """
+    An object for ordering during querying
+    """
+    # 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)
+
+    # An enumerator for sort direction during querying
+    direction: Optional[OrderByOption_direction] = None
+    # The field to sort by.
+    field: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OrderByOption:
+        """
+        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: OrderByOption
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OrderByOption()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .order_by_option_direction import OrderByOption_direction
+
+        from .order_by_option_direction import OrderByOption_direction
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "direction": lambda n : setattr(self, 'direction', n.get_enum_value(OrderByOption_direction)),
+            "field": lambda n : setattr(self, 'field', 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_enum_value("direction", self.direction)
+        writer.write_str_value("field", self.field)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/order_by_option_direction.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+class OrderByOption_direction(str, Enum):
+    Asc = "asc",
+    Desc = "desc",
+

leadping/models/outbound_capacity_overview.py

@@ -0,0 +1,89 @@
+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 .outbound_phone_number_capacity import OutboundPhoneNumberCapacity
+    from .outbound_queue_item import OutboundQueueItem
+
+@dataclass
+class OutboundCapacityOverview(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 blockedCount property
+    blocked_count: Optional[int] = None
+    # The coolingPhoneNumbers property
+    cooling_phone_numbers: Optional[int] = None
+    # The healthyPhoneNumbers property
+    healthy_phone_numbers: Optional[int] = None
+    # The limitedPhoneNumbers property
+    limited_phone_numbers: Optional[int] = None
+    # The phoneNumbers property
+    phone_numbers: Optional[list[OutboundPhoneNumberCapacity]] = None
+    # The recentDecisions property
+    recent_decisions: Optional[list[OutboundQueueItem]] = None
+    # The scheduledCount property
+    scheduled_count: Optional[int] = None
+    # The smsCapacityRemainingToday property
+    sms_capacity_remaining_today: Optional[int] = None
+    # The voiceCapacityRemainingToday property
+    voice_capacity_remaining_today: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OutboundCapacityOverview:
+        """
+        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: OutboundCapacityOverview
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OutboundCapacityOverview()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .outbound_phone_number_capacity import OutboundPhoneNumberCapacity
+        from .outbound_queue_item import OutboundQueueItem
+
+        from .outbound_phone_number_capacity import OutboundPhoneNumberCapacity
+        from .outbound_queue_item import OutboundQueueItem
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "blockedCount": lambda n : setattr(self, 'blocked_count', n.get_int_value()),
+            "coolingPhoneNumbers": lambda n : setattr(self, 'cooling_phone_numbers', n.get_int_value()),
+            "healthyPhoneNumbers": lambda n : setattr(self, 'healthy_phone_numbers', n.get_int_value()),
+            "limitedPhoneNumbers": lambda n : setattr(self, 'limited_phone_numbers', n.get_int_value()),
+            "phoneNumbers": lambda n : setattr(self, 'phone_numbers', n.get_collection_of_object_values(OutboundPhoneNumberCapacity)),
+            "recentDecisions": lambda n : setattr(self, 'recent_decisions', n.get_collection_of_object_values(OutboundQueueItem)),
+            "scheduledCount": lambda n : setattr(self, 'scheduled_count', n.get_int_value()),
+            "smsCapacityRemainingToday": lambda n : setattr(self, 'sms_capacity_remaining_today', n.get_int_value()),
+            "voiceCapacityRemainingToday": lambda n : setattr(self, 'voice_capacity_remaining_today', 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_int_value("blockedCount", self.blocked_count)
+        writer.write_int_value("coolingPhoneNumbers", self.cooling_phone_numbers)
+        writer.write_int_value("healthyPhoneNumbers", self.healthy_phone_numbers)
+        writer.write_int_value("limitedPhoneNumbers", self.limited_phone_numbers)
+        writer.write_collection_of_object_values("phoneNumbers", self.phone_numbers)
+        writer.write_collection_of_object_values("recentDecisions", self.recent_decisions)
+        writer.write_int_value("scheduledCount", self.scheduled_count)
+        writer.write_int_value("smsCapacityRemainingToday", self.sms_capacity_remaining_today)
+        writer.write_int_value("voiceCapacityRemainingToday", self.voice_capacity_remaining_today)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/outbound_delivery_channel.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class OutboundDeliveryChannel(str, Enum):
+    Sms = "sms",
+    Voice = "voice",
+    Email = "email",
+    Webhook = "webhook",
+    Internal_notification = "internal_notification",
+

leadping/models/outbound_delivery_source.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class OutboundDeliverySource(str, Enum):
+    Manual = "manual",
+    Automation = "automation",
+    Campaign = "campaign",
+    Import_ = "import",
+    Api = "api",
+    System_notification = "system_notification",
+    Warmup = "warmup",
+    Retry = "retry",
+

leadping/models/outbound_delivery_status.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+class OutboundDeliveryStatus(str, Enum):
+    Pending = "pending",
+    Scheduled = "scheduled",
+    Reserved = "reserved",
+    Sending = "sending",
+    Sent = "sent",
+    Failed = "failed",
+    Skipped = "skipped",
+    Blocked = "blocked",
+    Cancelled = "cancelled",
+

leadping/models/outbound_phone_number_capacity.py

@@ -0,0 +1,70 @@
+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 .phone_number_outbound_health_status import PhoneNumberOutboundHealthStatus
+
+@dataclass
+class OutboundPhoneNumberCapacity(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)
+
+    # Defines phone-number outbound health states used by pacing.
+    health_status: Optional[PhoneNumberOutboundHealthStatus] = None
+    # The phoneNumber property
+    phone_number: Optional[str] = None
+    # The phoneNumberId property
+    phone_number_id: Optional[str] = None
+    # The smsRemainingToday property
+    sms_remaining_today: Optional[int] = None
+    # The voiceRemainingToday property
+    voice_remaining_today: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OutboundPhoneNumberCapacity:
+        """
+        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: OutboundPhoneNumberCapacity
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OutboundPhoneNumberCapacity()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .phone_number_outbound_health_status import PhoneNumberOutboundHealthStatus
+
+        from .phone_number_outbound_health_status import PhoneNumberOutboundHealthStatus
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "healthStatus": lambda n : setattr(self, 'health_status', n.get_enum_value(PhoneNumberOutboundHealthStatus)),
+            "phoneNumber": lambda n : setattr(self, 'phone_number', n.get_str_value()),
+            "phoneNumberId": lambda n : setattr(self, 'phone_number_id', n.get_str_value()),
+            "smsRemainingToday": lambda n : setattr(self, 'sms_remaining_today', n.get_int_value()),
+            "voiceRemainingToday": lambda n : setattr(self, 'voice_remaining_today', 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_enum_value("healthStatus", self.health_status)
+        writer.write_str_value("phoneNumber", self.phone_number)
+        writer.write_str_value("phoneNumberId", self.phone_number_id)
+        writer.write_int_value("smsRemainingToday", self.sms_remaining_today)
+        writer.write_int_value("voiceRemainingToday", self.voice_remaining_today)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/outbound_queue_item.py

@@ -0,0 +1,92 @@
+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 .outbound_delivery_channel import OutboundDeliveryChannel
+    from .outbound_delivery_source import OutboundDeliverySource
+    from .outbound_delivery_status import OutboundDeliveryStatus
+    from .outbound_queue_item_reason_code import OutboundQueueItem_reasonCode
+
+@dataclass
+class OutboundQueueItem(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)
+
+    # Defines outbound delivery channels protected by delivery control.
+    channel: Optional[OutboundDeliveryChannel] = None
+    # The id property
+    id: Optional[str] = None
+    # The phoneNumber property
+    phone_number: Optional[str] = None
+    # The reason property
+    reason: Optional[str] = None
+    # Structured reason codes for outbound pacing and blocking decisions.
+    reason_code: Optional[OutboundQueueItem_reasonCode] = None
+    # The scheduledSendAt property
+    scheduled_send_at: Optional[datetime.datetime] = None
+    # Defines the source that requested outbound delivery.
+    source: Optional[OutboundDeliverySource] = None
+    # Defines durable outbound delivery request statuses.
+    status: Optional[OutboundDeliveryStatus] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OutboundQueueItem:
+        """
+        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: OutboundQueueItem
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OutboundQueueItem()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .outbound_delivery_channel import OutboundDeliveryChannel
+        from .outbound_delivery_source import OutboundDeliverySource
+        from .outbound_delivery_status import OutboundDeliveryStatus
+        from .outbound_queue_item_reason_code import OutboundQueueItem_reasonCode
+
+        from .outbound_delivery_channel import OutboundDeliveryChannel
+        from .outbound_delivery_source import OutboundDeliverySource
+        from .outbound_delivery_status import OutboundDeliveryStatus
+        from .outbound_queue_item_reason_code import OutboundQueueItem_reasonCode
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "channel": lambda n : setattr(self, 'channel', n.get_enum_value(OutboundDeliveryChannel)),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "phoneNumber": lambda n : setattr(self, 'phone_number', n.get_str_value()),
+            "reason": lambda n : setattr(self, 'reason', n.get_str_value()),
+            "reasonCode": lambda n : setattr(self, 'reason_code', n.get_enum_value(OutboundQueueItem_reasonCode)),
+            "scheduledSendAt": lambda n : setattr(self, 'scheduled_send_at', n.get_datetime_value()),
+            "source": lambda n : setattr(self, 'source', n.get_enum_value(OutboundDeliverySource)),
+            "status": lambda n : setattr(self, 'status', n.get_enum_value(OutboundDeliveryStatus)),
+        }
+        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_enum_value("channel", self.channel)
+        writer.write_str_value("id", self.id)
+        writer.write_str_value("phoneNumber", self.phone_number)
+        writer.write_str_value("reason", self.reason)
+        writer.write_enum_value("reasonCode", self.reason_code)
+        writer.write_datetime_value("scheduledSendAt", self.scheduled_send_at)
+        writer.write_enum_value("source", self.source)
+        writer.write_enum_value("status", self.status)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/outbound_queue_item_reason_code.py

@@ -0,0 +1,27 @@
+from enum import Enum
+
+class OutboundQueueItem_reasonCode(str, Enum):
+    Allowed = "allowed",
+    No_eligible_phone_number = "no_eligible_phone_number",
+    Ten_dlc_not_approved = "ten_dlc_not_approved",
+    Phone_number_daily_limit_reached = "phone_number_daily_limit_reached",
+    Phone_number_hourly_limit_reached = "phone_number_hourly_limit_reached",
+    Phone_number_minute_limit_reached = "phone_number_minute_limit_reached",
+    Business_daily_limit_reached = "business_daily_limit_reached",
+    Business_hourly_limit_reached = "business_hourly_limit_reached",
+    Business_minute_limit_reached = "business_minute_limit_reached",
+    Lead_daily_limit_reached = "lead_daily_limit_reached",
+    Lead_hourly_limit_reached = "lead_hourly_limit_reached",
+    Lead_recently_contacted = "lead_recently_contacted",
+    Lead_archived = "lead_archived",
+    Quiet_hours = "quiet_hours",
+    Wallet_insufficient = "wallet_insufficient",
+    Contact_opted_out = "contact_opted_out",
+    Imported_lead_requires_consent = "imported_lead_requires_consent",
+    Automation_bulk_import_disabled = "automation_bulk_import_disabled",
+    Number_cooling_down = "number_cooling_down",
+    Number_health_blocked = "number_health_blocked",
+    Provider_failure_backoff = "provider_failure_backoff",
+    Campaign_daily_limit_reached = "campaign_daily_limit_reached",
+    Reservation_unavailable = "reservation_unavailable",
+